This cluster supports all DoorLock features. It may support illegal feature combinations.

If you use this cluster you must manually specify which features are active and ensure the set of active features is legal per the Matter specification.

interface Complete {
    attributes: Merge<{
        acceptedCommandList: Attribute<CommandId[], never>;
        actuatorEnabled: Attribute<boolean, any>;
        alarmMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
            doorForcedOpen: BitFlag;
            frontEscutcheonRemoved: BitFlag;
            lockFactoryReset: BitFlag;
            lockJammed: BitFlag;
            lockRadioPowerCycled: BitFlag;
            na: BitFlag;
            wrongCodeEntryLimit: BitFlag;
        }>, any>;
        attributeList: Attribute<AttributeId[], never>;
        autoRelockTime: OptionalWritableAttribute<number, any>;
        clusterRevision: Attribute<number, never>;
        credentialRulesSupport: FixedAttribute<TypeFromPartialBitSchema<{
            dual: BitFlag;
            single: BitFlag;
            tri: BitFlag;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                user: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        defaultConfigurationRegister: OptionalAttribute<TypeFromPartialBitSchema<{
            autoRelockTime: BitFlag;
            keypadInterface: BitFlag;
            ledSettings: BitFlag;
            localProgramming: BitFlag;
            remoteInterface: BitFlag;
            soundVolume: BitFlag;
        }>, any>;
        doorClosedEvents: OptionalWritableAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                doorPositionSensor: boolean;
            }];
        };
        doorOpenEvents: OptionalWritableAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                doorPositionSensor: boolean;
            }];
        };
        doorState: Attribute<null | DoorLock.DoorState, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                doorPositionSensor: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        enableInsideStatusLed: OptionalWritableAttribute<boolean, any>;
        enableLocalProgramming: OptionalWritableAttribute<boolean, any>;
        enableLogging: WritableAttribute<boolean, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                logging: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        enableOneTouchLocking: OptionalWritableAttribute<boolean, any>;
        enablePrivacyModeButton: OptionalWritableAttribute<boolean, any>;
        expiringUserTimeout: OptionalWritableAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                user: boolean;
            }];
        };
        featureMap: Attribute<TypeFromPartialBitSchema<{
            credentialOverTheAirAccess: BitFlag;
            doorPositionSensor: BitFlag;
            faceCredentials: BitFlag;
            fingerCredentials: BitFlag;
            holidaySchedules: BitFlag;
            logging: BitFlag;
            notification: BitFlag;
            pinCredential: BitFlag;
            rfidCredential: BitFlag;
            unbolting: BitFlag;
            user: BitFlag;
            weekDayAccessSchedules: BitFlag;
            yearDayAccessSchedules: BitFlag;
        }>, never>;
        generatedCommandList: Attribute<CommandId[], never>;
        keypadOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
            bit0: BitFlag;
            bit1: BitFlag;
            bit10: BitFlag;
            bit11: BitFlag;
            bit12: BitFlag;
            bit13: BitFlag;
            bit14: BitFlag;
            bit15: BitFlag;
            bit2: BitFlag;
            bit3: BitFlag;
            bit4: BitFlag;
            bit5: BitFlag;
            bit6: BitFlag;
            bit7: BitFlag;
            bit8: BitFlag;
            bit9: BitFlag;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                notification: boolean;
                pinCredential: boolean;
            }];
        };
        keypadProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
            pinAdded: BitFlag;
            pinChanged: BitFlag;
            pinCleared: BitFlag;
            pinCodeChanged: BitFlag;
            unknown: BitFlag;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                notification: boolean;
                pinCredential: boolean;
            }];
        };
        language: OptionalWritableAttribute<string, any>;
        ledSettings: OptionalWritableAttribute<DoorLock.LedSetting, any>;
        localProgrammingFeatures: OptionalWritableAttribute<TypeFromPartialBitSchema<{
            addUsersCredentialsSchedules: BitFlag;
            adjustSettings: BitFlag;
            clearUsersCredentialsSchedules: BitFlag;
            modifyUsersCredentialsSchedules: BitFlag;
        }>, any>;
        lockState: Attribute<null | DoorLock.LockState, any>;
        lockType: Attribute<DoorLock.LockType, any>;
        manualOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
            bit0: BitFlag;
            bit1: BitFlag;
            bit10: BitFlag;
            bit11: BitFlag;
            bit12: BitFlag;
            bit13: BitFlag;
            bit14: BitFlag;
            bit15: BitFlag;
            bit2: BitFlag;
            bit3: BitFlag;
            bit4: BitFlag;
            bit5: BitFlag;
            bit6: BitFlag;
            bit7: BitFlag;
            bit8: BitFlag;
            bit9: BitFlag;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                notification: boolean;
            }];
        };
        maxPinCodeLength: FixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                pinCredential: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        maxRfidCodeLength: FixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                rfidCredential: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        minPinCodeLength: FixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                pinCredential: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        minRfidCodeLength: FixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                rfidCredential: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        numberOfCredentialsSupportedPerUser: FixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                user: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        numberOfHolidaySchedulesSupported: FixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                holidaySchedules: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        numberOfLogRecordsSupported: FixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                logging: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        numberOfPinUsersSupported: FixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                pinCredential: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        numberOfRfidUsersSupported: FixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                rfidCredential: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        numberOfTotalUsersSupported: FixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                user: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        numberOfWeekDaySchedulesSupportedPerUser: FixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                weekDayAccessSchedules: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        numberOfYearDaySchedulesSupportedPerUser: FixedAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                yearDayAccessSchedules: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        openPeriod: OptionalWritableAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                doorPositionSensor: boolean;
            }];
        };
        operatingMode: WritableAttribute<DoorLock.OperatingMode, any>;
        remoteOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
            bit0: BitFlag;
            bit1: BitFlag;
            bit10: BitFlag;
            bit11: BitFlag;
            bit12: BitFlag;
            bit13: BitFlag;
            bit14: BitFlag;
            bit15: BitFlag;
            bit2: BitFlag;
            bit3: BitFlag;
            bit4: BitFlag;
            bit5: BitFlag;
            bit6: BitFlag;
            bit7: BitFlag;
            bit8: BitFlag;
            bit9: BitFlag;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                notification: boolean;
            }];
        };
        remoteProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
            pinAdded: BitFlag;
            pinChanged: BitFlag;
            pinCleared: BitFlag;
            rfidCodeAdded: BitFlag;
            rfidCodeCleared: BitFlag;
            unknown: BitFlag;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                notification: boolean;
            }];
        };
        requirePinForRemoteOperation: WritableAttribute<boolean, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                credentialOverTheAirAccess: boolean;
                pinCredential: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        rfidOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
            bit0: BitFlag;
            bit1: BitFlag;
            bit10: BitFlag;
            bit11: BitFlag;
            bit12: BitFlag;
            bit13: BitFlag;
            bit14: BitFlag;
            bit15: BitFlag;
            bit2: BitFlag;
            bit3: BitFlag;
            bit4: BitFlag;
            bit5: BitFlag;
            bit6: BitFlag;
            bit7: BitFlag;
            bit8: BitFlag;
            bit9: BitFlag;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                notification: boolean;
                rfidCredential: boolean;
            }];
        };
        rfidProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
            idAdded: BitFlag;
            idCleared: BitFlag;
            unknown: BitFlag;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                notification: boolean;
                rfidCredential: boolean;
            }];
        };
        sendPinOverTheAir: OptionalWritableAttribute<boolean, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                pinCredential: boolean;
                user: boolean;
            }];
        };
        soundVolume: OptionalWritableAttribute<DoorLock.SoundVolume, any>;
        supportedOperatingModes: FixedAttribute<TypeFromPartialBitSchema<{
            noRemoteLockUnlock: BitFlag;
            normal: BitFlag;
            passage: BitFlag;
            privacy: BitFlag;
            vacation: BitFlag;
        }>, any>;
        userCodeTemporaryDisableTime: WritableAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                pinCredential: boolean;
            }, {
                rfidCredential: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        wrongCodeEntryLimit: WritableAttribute<number, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                pinCredential: boolean;
            }, {
                rfidCredential: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    }, GlobalAttributes<{
        credentialOverTheAirAccess: BitFlag;
        doorPositionSensor: BitFlag;
        faceCredentials: BitFlag;
        fingerCredentials: BitFlag;
        holidaySchedules: BitFlag;
        logging: BitFlag;
        notification: BitFlag;
        pinCredential: BitFlag;
        rfidCredential: BitFlag;
        unbolting: BitFlag;
        user: BitFlag;
        weekDayAccessSchedules: BitFlag;
        yearDayAccessSchedules: BitFlag;
    }>>;
    base: undefined;
    commands: {
        clearAllPinCodes: Command<void, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                pinCredential: boolean;
                user: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        clearAllRfidCodes: Command<void, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                rfidCredential: boolean;
                user: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        clearCredential: Command<TypeFromFields<{
            credential: FieldType<null | TypeFromFields<{
                credentialIndex: FieldType<number>;
                credentialType: FieldType<DoorLock.CredentialType>;
            }>>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                user: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        clearHolidaySchedule: Command<TypeFromFields<{
            holidayIndex: FieldType<number>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                holidaySchedules: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        clearPinCode: Command<TypeFromFields<{
            pinSlotIndex: FieldType<number>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                pinCredential: boolean;
                user: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        clearRfidCode: Command<TypeFromFields<{
            rfidSlotIndex: FieldType<number>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                rfidCredential: boolean;
                user: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        clearUser: Command<TypeFromFields<{
            userIndex: FieldType<number>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                user: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        clearWeekDaySchedule: Command<TypeFromFields<{
            userIndexUserId: FieldType<number>;
            weekDayIndex: FieldType<number>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                weekDayAccessSchedules: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        clearYearDaySchedule: Command<TypeFromFields<{
            userIndexUserId: FieldType<number>;
            yearDayIndex: FieldType<number>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                yearDayAccessSchedules: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        getCredentialStatus: Command<TypeFromFields<{
            credential: FieldType<TypeFromFields<{
                credentialIndex: FieldType<number>;
                credentialType: FieldType<DoorLock.CredentialType>;
            }>>;
        }>, TypeFromFields<{
            creatorFabricIndex: FieldType<null | FabricIndex>;
            credentialExists: FieldType<boolean>;
            lastModifiedFabricIndex: FieldType<null | FabricIndex>;
            nextCredentialIndex: OptionalFieldType<null | number>;
            userIndex: FieldType<null | number>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                user: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        getHolidaySchedule: Command<TypeFromFields<{
            holidayIndex: FieldType<number>;
        }>, TypeFromFields<{
            holidayIndex: FieldType<number>;
            localEndTime: OptionalFieldType<null | number>;
            localStartTime: OptionalFieldType<null | number>;
            operatingMode: OptionalFieldType<null | DoorLock.OperatingMode>;
            status: FieldType<Status>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                holidaySchedules: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        getLogRecord: Command<TypeFromFields<{
            logIndex: FieldType<number>;
        }>, TypeFromFields<{
            eventId: FieldType<number>;
            eventType: FieldType<DoorLock.EventType>;
            logEntryId: FieldType<number>;
            pin: FieldType<Uint8Array>;
            source: FieldType<DoorLock.EventSource>;
            timestamp: FieldType<number>;
            userId: FieldType<number>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                logging: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        getPinCode: Command<TypeFromFields<{
            userId: FieldType<number>;
        }>, TypeFromFields<{
            pinCode: FieldType<null | Uint8Array>;
            userId: FieldType<number>;
            userStatus: FieldType<null | DoorLock.UserStatus>;
            userType: FieldType<null | DoorLock.UserType>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                pinCredential: boolean;
                user: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        getRfidCode: Command<TypeFromFields<{
            userId: FieldType<number>;
        }>, TypeFromFields<{
            rfidCode: FieldType<null | Uint8Array>;
            userId: FieldType<number>;
            userStatus: FieldType<null | DoorLock.UserStatus>;
            userType: FieldType<null | DoorLock.UserType>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                rfidCredential: boolean;
                user: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        getUser: Command<TypeFromFields<{
            userIndex: FieldType<number>;
        }>, TypeFromFields<{
            creatorFabricIndex: FieldType<null | FabricIndex>;
            credentialRule: FieldType<null | DoorLock.CredentialRule>;
            credentials: FieldType<null | TypeFromFields<{
                credentialIndex: FieldType<(...)>;
                credentialType: FieldType<(...)>;
            }>[]>;
            lastModifiedFabricIndex: FieldType<null | FabricIndex>;
            nextUserIndex: FieldType<null | number>;
            userIndex: FieldType<number>;
            userName: FieldType<null | string>;
            userStatus: FieldType<null | DoorLock.UserStatus>;
            userType: FieldType<null | DoorLock.UserType>;
            userUniqueId: FieldType<null | number>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                user: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        getUserStatus: OptionalCommand<TypeFromFields<{
            userId: FieldType<number>;
        }>, TypeFromFields<{
            userId: FieldType<number>;
            userStatus: FieldType<DoorLock.UserStatus>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                fingerCredentials: boolean;
                pinCredential: boolean;
                rfidCredential: boolean;
                user: boolean;
            }];
        };
        getUserType: OptionalCommand<TypeFromFields<{
            userId: FieldType<number>;
        }>, TypeFromFields<{
            userId: FieldType<number>;
            userType: FieldType<DoorLock.UserType>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                fingerCredentials: boolean;
                pinCredential: boolean;
                rfidCredential: boolean;
                user: boolean;
            }];
        };
        getWeekDaySchedule: Command<TypeFromFields<{
            userIndexUserId: FieldType<number>;
            weekDayIndex: FieldType<number>;
        }>, TypeFromFields<{
            daysMask: OptionalFieldType<TypeFromPartialBitSchema<{
                friday: BitFlag;
                monday: BitFlag;
                saturday: BitFlag;
                sunday: BitFlag;
                thursday: BitFlag;
                tuesday: BitFlag;
                wednesday: BitFlag;
            }>>;
            endHour: OptionalFieldType<number>;
            endMinute: OptionalFieldType<number>;
            startHour: OptionalFieldType<number>;
            startMinute: OptionalFieldType<number>;
            status: FieldType<Status>;
            userIndexUserId: FieldType<number>;
            weekDayIndex: FieldType<number>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                weekDayAccessSchedules: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        getYearDaySchedule: Command<TypeFromFields<{
            userIndexUserId: FieldType<number>;
            yearDayIndex: FieldType<number>;
        }>, TypeFromFields<{
            localEndTime: OptionalFieldType<number>;
            localStartTime: OptionalFieldType<number>;
            status: FieldType<Status>;
            userIndexUserId: FieldType<number>;
            yearDayIndex: FieldType<number>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                yearDayAccessSchedules: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        lockDoor: Command<TypeFromFields<{
            pinCode: OptionalFieldType<Uint8Array>;
        }>, void, any>;
        setCredential: Command<TypeFromFields<{
            credential: FieldType<TypeFromFields<{
                credentialIndex: FieldType<number>;
                credentialType: FieldType<DoorLock.CredentialType>;
            }>>;
            credentialData: FieldType<Uint8Array>;
            operationType: FieldType<DoorLock.DataOperationType>;
            userIndex: FieldType<null | number>;
            userStatus: FieldType<null | DoorLock.UserStatus>;
            userType: FieldType<null | DoorLock.UserType>;
        }>, TypeFromFields<{
            nextCredentialIndex: OptionalFieldType<null | number>;
            status: FieldType<Status>;
            userIndex: FieldType<null | number>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                user: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        setHolidaySchedule: Command<TypeFromFields<{
            holidayIndex: FieldType<number>;
            localEndTime: FieldType<number>;
            localStartTime: FieldType<number>;
            operatingMode: FieldType<DoorLock.OperatingMode>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                holidaySchedules: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        setPinCode: Command<TypeFromFields<{
            pin: FieldType<Uint8Array>;
            userId: FieldType<number>;
            userStatus: FieldType<null | DoorLock.UserStatus>;
            userType: FieldType<null | DoorLock.UserType>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                pinCredential: boolean;
                user: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        setRfidCode: Command<TypeFromFields<{
            rfidCode: FieldType<Uint8Array>;
            userId: FieldType<number>;
            userStatus: FieldType<null | DoorLock.UserStatus>;
            userType: FieldType<null | DoorLock.UserType>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                rfidCredential: boolean;
                user: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        setUser: Command<TypeFromFields<{
            credentialRule: FieldType<null | DoorLock.CredentialRule>;
            operationType: FieldType<DoorLock.DataOperationType>;
            userIndex: FieldType<number>;
            userName: FieldType<null | string>;
            userStatus: FieldType<null | DoorLock.UserStatus>;
            userType: FieldType<null | DoorLock.UserType>;
            userUniqueId: FieldType<null | number>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                user: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        setUserStatus: OptionalCommand<TypeFromFields<{
            userId: FieldType<number>;
            userStatus: FieldType<DoorLock.UserStatus>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                fingerCredentials: boolean;
                pinCredential: boolean;
                rfidCredential: boolean;
                user: boolean;
            }];
        };
        setUserType: OptionalCommand<TypeFromFields<{
            userId: FieldType<number>;
            userType: FieldType<DoorLock.UserType>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
            optional: true;
            optionalIf: [] | [{
                fingerCredentials: boolean;
                pinCredential: boolean;
                rfidCredential: boolean;
                user: boolean;
            }];
        };
        setWeekDaySchedule: Command<TypeFromFields<{
            daysMask: FieldType<TypeFromPartialBitSchema<{
                friday: BitFlag;
                monday: BitFlag;
                saturday: BitFlag;
                sunday: BitFlag;
                thursday: BitFlag;
                tuesday: BitFlag;
                wednesday: BitFlag;
            }>>;
            endHour: FieldType<number>;
            endMinute: FieldType<number>;
            startHour: FieldType<number>;
            startMinute: FieldType<number>;
            userIndexUserId: FieldType<number>;
            weekDayIndex: FieldType<number>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                weekDayAccessSchedules: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        setYearDaySchedule: Command<TypeFromFields<{
            localEndTime: FieldType<number>;
            localStartTime: FieldType<number>;
            userIndexUserId: FieldType<number>;
            yearDayIndex: FieldType<number>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                yearDayAccessSchedules: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        unboltDoor: Command<TypeFromFields<{
            pinCode: OptionalFieldType<Uint8Array>;
        }>, void, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                unbolting: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        unlockDoor: Command<TypeFromFields<{
            pinCode: OptionalFieldType<Uint8Array>;
        }>, void, any>;
        unlockWithTimeout: OptionalCommand<TypeFromFields<{
            pinCode: OptionalFieldType<Uint8Array>;
            timeout: FieldType<number>;
        }>, void, any>;
    };
    events: {
        doorLockAlarm: Event<TypeFromFields<{
            alarmCode: FieldType<DoorLock.AlarmCode>;
        }>, any>;
        doorStateChange: Event<TypeFromFields<{
            doorState: FieldType<DoorLock.DoorState>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                doorPositionSensor: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
        lockOperation: Event<TypeFromFields<{
            credentials: OptionalFieldType<null | TypeFromFields<{
                credentialIndex: FieldType<number>;
                credentialType: FieldType<DoorLock.CredentialType>;
            }>[]>;
            fabricIndex: FieldType<null | FabricIndex>;
            lockOperationType: FieldType<DoorLock.LockOperationType>;
            operationSource: FieldType<DoorLock.OperationSource>;
            sourceNode: FieldType<null | NodeId>;
            userIndex: FieldType<null | number>;
        }>, any>;
        lockOperationError: Event<TypeFromFields<{
            credentials: OptionalFieldType<null | TypeFromFields<{
                credentialIndex: FieldType<number>;
                credentialType: FieldType<DoorLock.CredentialType>;
            }>[]>;
            fabricIndex: FieldType<null | FabricIndex>;
            lockOperationType: FieldType<DoorLock.LockOperationType>;
            operationError: FieldType<DoorLock.OperationError>;
            operationSource: FieldType<DoorLock.OperationSource>;
            sourceNode: FieldType<null | NodeId>;
            userIndex: FieldType<null | number>;
        }>, any>;
        lockUserChange: Event<TypeFromFields<{
            dataIndex: FieldType<null | number>;
            dataOperationType: FieldType<DoorLock.DataOperationType>;
            fabricIndex: FieldType<null | FabricIndex>;
            lockDataType: FieldType<DoorLock.LockDataType>;
            operationSource: FieldType<DoorLock.OperationSource>;
            sourceNode: FieldType<null | NodeId>;
            userIndex: FieldType<null | number>;
        }>, any> & {
            isConditional: true;
            mandatoryIf: [] | [{
                user: boolean;
            }];
            optional: true;
            optionalIf: [] | ConditionalFeatureList<BitSchema>;
        };
    };
    extensions: undefined;
    features: {
        credentialOverTheAirAccess: BitFlag;
        doorPositionSensor: BitFlag;
        faceCredentials: BitFlag;
        fingerCredentials: BitFlag;
        holidaySchedules: BitFlag;
        logging: BitFlag;
        notification: BitFlag;
        pinCredential: BitFlag;
        rfidCredential: BitFlag;
        unbolting: BitFlag;
        user: BitFlag;
        weekDayAccessSchedules: BitFlag;
        yearDayAccessSchedules: BitFlag;
    };
    id: Branded<Branded<257, "ClusterId">, "ClusterId">;
    name: "DoorLock";
    revision: 7;
    supportedFeatures: {};
    unknown: false;
    alter<const AlterationsT>(alterations: AlterationsT): WithAlterations<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            actuatorEnabled: Attribute<boolean, any>;
            alarmMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                doorForcedOpen: BitFlag;
                frontEscutcheonRemoved: BitFlag;
                lockFactoryReset: BitFlag;
                lockJammed: BitFlag;
                lockRadioPowerCycled: BitFlag;
                na: BitFlag;
                wrongCodeEntryLimit: BitFlag;
            }>, any>;
            attributeList: Attribute<AttributeId[], never>;
            autoRelockTime: OptionalWritableAttribute<number, any>;
            clusterRevision: Attribute<number, never>;
            credentialRulesSupport: FixedAttribute<TypeFromPartialBitSchema<{
                dual: BitFlag;
                single: BitFlag;
                tri: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            defaultConfigurationRegister: OptionalAttribute<TypeFromPartialBitSchema<{
                autoRelockTime: BitFlag;
                keypadInterface: BitFlag;
                ledSettings: BitFlag;
                localProgramming: BitFlag;
                remoteInterface: BitFlag;
                soundVolume: BitFlag;
            }>, any>;
            doorClosedEvents: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    doorPositionSensor: boolean;
                }];
            };
            doorOpenEvents: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    doorPositionSensor: boolean;
                }];
            };
            doorState: Attribute<null | DoorLock.DoorState, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    doorPositionSensor: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            enableInsideStatusLed: OptionalWritableAttribute<boolean, any>;
            enableLocalProgramming: OptionalWritableAttribute<boolean, any>;
            enableLogging: WritableAttribute<boolean, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    logging: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            enableOneTouchLocking: OptionalWritableAttribute<boolean, any>;
            enablePrivacyModeButton: OptionalWritableAttribute<boolean, any>;
            expiringUserTimeout: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    user: boolean;
                }];
            };
            featureMap: Attribute<TypeFromPartialBitSchema<{
                credentialOverTheAirAccess: BitFlag;
                doorPositionSensor: BitFlag;
                faceCredentials: BitFlag;
                fingerCredentials: BitFlag;
                holidaySchedules: BitFlag;
                logging: BitFlag;
                notification: BitFlag;
                pinCredential: BitFlag;
                rfidCredential: BitFlag;
                unbolting: BitFlag;
                user: BitFlag;
                weekDayAccessSchedules: BitFlag;
                yearDayAccessSchedules: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            keypadOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                bit0: BitFlag;
                bit1: BitFlag;
                bit10: BitFlag;
                bit11: BitFlag;
                bit12: BitFlag;
                bit13: BitFlag;
                bit14: BitFlag;
                bit15: BitFlag;
                bit2: BitFlag;
                bit3: BitFlag;
                bit4: BitFlag;
                bit5: BitFlag;
                bit6: BitFlag;
                bit7: BitFlag;
                bit8: BitFlag;
                bit9: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                    pinCredential: boolean;
                }];
            };
            keypadProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                pinAdded: BitFlag;
                pinChanged: BitFlag;
                pinCleared: BitFlag;
                pinCodeChanged: BitFlag;
                unknown: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                    pinCredential: boolean;
                }];
            };
            language: OptionalWritableAttribute<string, any>;
            ledSettings: OptionalWritableAttribute<DoorLock.LedSetting, any>;
            localProgrammingFeatures: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                addUsersCredentialsSchedules: BitFlag;
                adjustSettings: BitFlag;
                clearUsersCredentialsSchedules: BitFlag;
                modifyUsersCredentialsSchedules: BitFlag;
            }>, any>;
            lockState: Attribute<null | DoorLock.LockState, any>;
            lockType: Attribute<DoorLock.LockType, any>;
            manualOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                bit0: BitFlag;
                bit1: BitFlag;
                bit10: BitFlag;
                bit11: BitFlag;
                bit12: BitFlag;
                bit13: BitFlag;
                bit14: BitFlag;
                bit15: BitFlag;
                bit2: BitFlag;
                bit3: BitFlag;
                bit4: BitFlag;
                bit5: BitFlag;
                bit6: BitFlag;
                bit7: BitFlag;
                bit8: BitFlag;
                bit9: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                }];
            };
            maxPinCodeLength: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            maxRfidCodeLength: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minPinCodeLength: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minRfidCodeLength: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfCredentialsSupportedPerUser: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfHolidaySchedulesSupported: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    holidaySchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfLogRecordsSupported: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    logging: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfPinUsersSupported: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfRfidUsersSupported: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfTotalUsersSupported: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfWeekDaySchedulesSupportedPerUser: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    weekDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfYearDaySchedulesSupportedPerUser: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    yearDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            openPeriod: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    doorPositionSensor: boolean;
                }];
            };
            operatingMode: WritableAttribute<DoorLock.OperatingMode, any>;
            remoteOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                bit0: BitFlag;
                bit1: BitFlag;
                bit10: BitFlag;
                bit11: BitFlag;
                bit12: BitFlag;
                bit13: BitFlag;
                bit14: BitFlag;
                bit15: BitFlag;
                bit2: BitFlag;
                bit3: BitFlag;
                bit4: BitFlag;
                bit5: BitFlag;
                bit6: BitFlag;
                bit7: BitFlag;
                bit8: BitFlag;
                bit9: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                }];
            };
            remoteProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                pinAdded: BitFlag;
                pinChanged: BitFlag;
                pinCleared: BitFlag;
                rfidCodeAdded: BitFlag;
                rfidCodeCleared: BitFlag;
                unknown: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                }];
            };
            requirePinForRemoteOperation: WritableAttribute<boolean, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    credentialOverTheAirAccess: boolean;
                    pinCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            rfidOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                bit0: BitFlag;
                bit1: BitFlag;
                bit10: BitFlag;
                bit11: BitFlag;
                bit12: BitFlag;
                bit13: BitFlag;
                bit14: BitFlag;
                bit15: BitFlag;
                bit2: BitFlag;
                bit3: BitFlag;
                bit4: BitFlag;
                bit5: BitFlag;
                bit6: BitFlag;
                bit7: BitFlag;
                bit8: BitFlag;
                bit9: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                    rfidCredential: boolean;
                }];
            };
            rfidProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                idAdded: BitFlag;
                idCleared: BitFlag;
                unknown: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                    rfidCredential: boolean;
                }];
            };
            sendPinOverTheAir: OptionalWritableAttribute<boolean, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    pinCredential: boolean;
                    user: boolean;
                }];
            };
            soundVolume: OptionalWritableAttribute<DoorLock.SoundVolume, any>;
            supportedOperatingModes: FixedAttribute<TypeFromPartialBitSchema<{
                noRemoteLockUnlock: BitFlag;
                normal: BitFlag;
                passage: BitFlag;
                privacy: BitFlag;
                vacation: BitFlag;
            }>, any>;
            userCodeTemporaryDisableTime: WritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                }, {
                    rfidCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            wrongCodeEntryLimit: WritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                }, {
                    rfidCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            clearAllPinCodes: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearAllRfidCodes: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearCredential: Command<TypeFromFields<{
                credential: FieldType<null | TypeFromFields<(...)>>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearHolidaySchedule: Command<TypeFromFields<{
                holidayIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    holidaySchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearPinCode: Command<TypeFromFields<{
                pinSlotIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearRfidCode: Command<TypeFromFields<{
                rfidSlotIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearUser: Command<TypeFromFields<{
                userIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearWeekDaySchedule: Command<TypeFromFields<{
                userIndexUserId: FieldType<number>;
                weekDayIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    weekDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearYearDaySchedule: Command<TypeFromFields<{
                userIndexUserId: FieldType<number>;
                yearDayIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    yearDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getCredentialStatus: Command<TypeFromFields<{
                credential: FieldType<TypeFromFields<{
                    credentialIndex: ...;
                    credentialType: ...;
                }>>;
            }>, TypeFromFields<{
                creatorFabricIndex: FieldType<null | FabricIndex>;
                credentialExists: FieldType<boolean>;
                lastModifiedFabricIndex: FieldType<null | FabricIndex>;
                nextCredentialIndex: OptionalFieldType<null | number>;
                userIndex: FieldType<null | number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getHolidaySchedule: Command<TypeFromFields<{
                holidayIndex: FieldType<number>;
            }>, TypeFromFields<{
                holidayIndex: FieldType<number>;
                localEndTime: OptionalFieldType<null | number>;
                localStartTime: OptionalFieldType<null | number>;
                operatingMode: OptionalFieldType<null | DoorLock.OperatingMode>;
                status: FieldType<Status>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    holidaySchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getLogRecord: Command<TypeFromFields<{
                logIndex: FieldType<number>;
            }>, TypeFromFields<{
                eventId: FieldType<number>;
                eventType: FieldType<DoorLock.EventType>;
                logEntryId: FieldType<number>;
                pin: FieldType<Uint8Array>;
                source: FieldType<DoorLock.EventSource>;
                timestamp: FieldType<number>;
                userId: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    logging: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getPinCode: Command<TypeFromFields<{
                userId: FieldType<number>;
            }>, TypeFromFields<{
                pinCode: FieldType<null | Uint8Array>;
                userId: FieldType<number>;
                userStatus: FieldType<null | DoorLock.UserStatus>;
                userType: FieldType<null | DoorLock.UserType>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getRfidCode: Command<TypeFromFields<{
                userId: FieldType<number>;
            }>, TypeFromFields<{
                rfidCode: FieldType<null | Uint8Array>;
                userId: FieldType<number>;
                userStatus: FieldType<null | DoorLock.UserStatus>;
                userType: FieldType<null | DoorLock.UserType>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getUser: Command<TypeFromFields<{
                userIndex: FieldType<number>;
            }>, TypeFromFields<{
                creatorFabricIndex: FieldType<null | FabricIndex>;
                credentialRule: FieldType<null | DoorLock.CredentialRule>;
                credentials: FieldType<null | (...)[]>;
                lastModifiedFabricIndex: FieldType<null | FabricIndex>;
                nextUserIndex: FieldType<null | number>;
                userIndex: FieldType<number>;
                userName: FieldType<null | string>;
                userStatus: FieldType<null | DoorLock.UserStatus>;
                userType: FieldType<null | DoorLock.UserType>;
                userUniqueId: FieldType<null | number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getUserStatus: OptionalCommand<TypeFromFields<{
                userId: FieldType<number>;
            }>, TypeFromFields<{
                userId: FieldType<number>;
                userStatus: FieldType<DoorLock.UserStatus>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    fingerCredentials: boolean;
                    pinCredential: boolean;
                    rfidCredential: boolean;
                    user: boolean;
                }];
            };
            getUserType: OptionalCommand<TypeFromFields<{
                userId: FieldType<number>;
            }>, TypeFromFields<{
                userId: FieldType<number>;
                userType: FieldType<DoorLock.UserType>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    fingerCredentials: boolean;
                    pinCredential: boolean;
                    rfidCredential: boolean;
                    user: boolean;
                }];
            };
            getWeekDaySchedule: Command<TypeFromFields<{
                userIndexUserId: FieldType<number>;
                weekDayIndex: FieldType<number>;
            }>, TypeFromFields<{
                daysMask: OptionalFieldType<TypeFromPartialBitSchema<{
                    friday: ...;
                    monday: ...;
                    saturday: ...;
                    sunday: ...;
                    thursday: ...;
                    tuesday: ...;
                    wednesday: ...;
                }>>;
                endHour: OptionalFieldType<number>;
                endMinute: OptionalFieldType<number>;
                startHour: OptionalFieldType<number>;
                startMinute: OptionalFieldType<number>;
                status: FieldType<Status>;
                userIndexUserId: FieldType<number>;
                weekDayIndex: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    weekDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getYearDaySchedule: Command<TypeFromFields<{
                userIndexUserId: FieldType<number>;
                yearDayIndex: FieldType<number>;
            }>, TypeFromFields<{
                localEndTime: OptionalFieldType<number>;
                localStartTime: OptionalFieldType<number>;
                status: FieldType<Status>;
                userIndexUserId: FieldType<number>;
                yearDayIndex: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    yearDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            lockDoor: Command<TypeFromFields<{
                pinCode: OptionalFieldType<Uint8Array>;
            }>, void, any>;
            setCredential: Command<TypeFromFields<{
                credential: FieldType<TypeFromFields<{
                    credentialIndex: ...;
                    credentialType: ...;
                }>>;
                credentialData: FieldType<Uint8Array>;
                operationType: FieldType<DoorLock.DataOperationType>;
                userIndex: FieldType<null | number>;
                userStatus: FieldType<null | DoorLock.UserStatus>;
                userType: FieldType<null | DoorLock.UserType>;
            }>, TypeFromFields<{
                nextCredentialIndex: OptionalFieldType<null | number>;
                status: FieldType<Status>;
                userIndex: FieldType<null | number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setHolidaySchedule: Command<TypeFromFields<{
                holidayIndex: FieldType<number>;
                localEndTime: FieldType<number>;
                localStartTime: FieldType<number>;
                operatingMode: FieldType<DoorLock.OperatingMode>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    holidaySchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setPinCode: Command<TypeFromFields<{
                pin: FieldType<Uint8Array>;
                userId: FieldType<number>;
                userStatus: FieldType<null | DoorLock.UserStatus>;
                userType: FieldType<null | DoorLock.UserType>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setRfidCode: Command<TypeFromFields<{
                rfidCode: FieldType<Uint8Array>;
                userId: FieldType<number>;
                userStatus: FieldType<null | DoorLock.UserStatus>;
                userType: FieldType<null | DoorLock.UserType>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setUser: Command<TypeFromFields<{
                credentialRule: FieldType<null | DoorLock.CredentialRule>;
                operationType: FieldType<DoorLock.DataOperationType>;
                userIndex: FieldType<number>;
                userName: FieldType<null | string>;
                userStatus: FieldType<null | DoorLock.UserStatus>;
                userType: FieldType<null | DoorLock.UserType>;
                userUniqueId: FieldType<null | number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setUserStatus: OptionalCommand<TypeFromFields<{
                userId: FieldType<number>;
                userStatus: FieldType<DoorLock.UserStatus>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    fingerCredentials: boolean;
                    pinCredential: boolean;
                    rfidCredential: boolean;
                    user: boolean;
                }];
            };
            setUserType: OptionalCommand<TypeFromFields<{
                userId: FieldType<number>;
                userType: FieldType<DoorLock.UserType>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    fingerCredentials: boolean;
                    pinCredential: boolean;
                    rfidCredential: boolean;
                    user: boolean;
                }];
            };
            setWeekDaySchedule: Command<TypeFromFields<{
                daysMask: FieldType<TypeFromPartialBitSchema<{
                    friday: ...;
                    monday: ...;
                    saturday: ...;
                    sunday: ...;
                    thursday: ...;
                    tuesday: ...;
                    wednesday: ...;
                }>>;
                endHour: FieldType<number>;
                endMinute: FieldType<number>;
                startHour: FieldType<number>;
                startMinute: FieldType<number>;
                userIndexUserId: FieldType<number>;
                weekDayIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    weekDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setYearDaySchedule: Command<TypeFromFields<{
                localEndTime: FieldType<number>;
                localStartTime: FieldType<number>;
                userIndexUserId: FieldType<number>;
                yearDayIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    yearDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            unboltDoor: Command<TypeFromFields<{
                pinCode: OptionalFieldType<Uint8Array>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    unbolting: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            unlockDoor: Command<TypeFromFields<{
                pinCode: OptionalFieldType<Uint8Array>;
            }>, void, any>;
            unlockWithTimeout: OptionalCommand<TypeFromFields<{
                pinCode: OptionalFieldType<Uint8Array>;
                timeout: FieldType<number>;
            }>, void, any>;
        };
        events: {
            doorLockAlarm: Event<TypeFromFields<{
                alarmCode: FieldType<DoorLock.AlarmCode>;
            }>, any>;
            doorStateChange: Event<TypeFromFields<{
                doorState: FieldType<DoorLock.DoorState>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    doorPositionSensor: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            lockOperation: Event<TypeFromFields<{
                credentials: OptionalFieldType<null | TypeFromFields<(...)>[]>;
                fabricIndex: FieldType<null | FabricIndex>;
                lockOperationType: FieldType<DoorLock.LockOperationType>;
                operationSource: FieldType<DoorLock.OperationSource>;
                sourceNode: FieldType<null | NodeId>;
                userIndex: FieldType<null | number>;
            }>, any>;
            lockOperationError: Event<TypeFromFields<{
                credentials: OptionalFieldType<null | TypeFromFields<(...)>[]>;
                fabricIndex: FieldType<null | FabricIndex>;
                lockOperationType: FieldType<DoorLock.LockOperationType>;
                operationError: FieldType<DoorLock.OperationError>;
                operationSource: FieldType<DoorLock.OperationSource>;
                sourceNode: FieldType<null | NodeId>;
                userIndex: FieldType<null | number>;
            }>, any>;
            lockUserChange: Event<TypeFromFields<{
                dataIndex: FieldType<null | number>;
                dataOperationType: FieldType<DoorLock.DataOperationType>;
                fabricIndex: FieldType<null | FabricIndex>;
                lockDataType: FieldType<DoorLock.LockDataType>;
                operationSource: FieldType<DoorLock.OperationSource>;
                sourceNode: FieldType<null | NodeId>;
                userIndex: FieldType<null | number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            credentialOverTheAirAccess: BitFlag;
            doorPositionSensor: BitFlag;
            faceCredentials: BitFlag;
            fingerCredentials: BitFlag;
            holidaySchedules: BitFlag;
            logging: BitFlag;
            notification: BitFlag;
            pinCredential: BitFlag;
            rfidCredential: BitFlag;
            unbolting: BitFlag;
            user: BitFlag;
            weekDayAccessSchedules: BitFlag;
            yearDayAccessSchedules: BitFlag;
        };
        id: Branded<257, "ClusterId">;
        name: "DoorLock";
        revision: 7;
    }>, AlterationsT>;
    enable<const FlagsT>(flags: FlagsT): WithFlags<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            actuatorEnabled: Attribute<boolean, any>;
            alarmMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                doorForcedOpen: BitFlag;
                frontEscutcheonRemoved: BitFlag;
                lockFactoryReset: BitFlag;
                lockJammed: BitFlag;
                lockRadioPowerCycled: BitFlag;
                na: BitFlag;
                wrongCodeEntryLimit: BitFlag;
            }>, any>;
            attributeList: Attribute<AttributeId[], never>;
            autoRelockTime: OptionalWritableAttribute<number, any>;
            clusterRevision: Attribute<number, never>;
            credentialRulesSupport: FixedAttribute<TypeFromPartialBitSchema<{
                dual: BitFlag;
                single: BitFlag;
                tri: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            defaultConfigurationRegister: OptionalAttribute<TypeFromPartialBitSchema<{
                autoRelockTime: BitFlag;
                keypadInterface: BitFlag;
                ledSettings: BitFlag;
                localProgramming: BitFlag;
                remoteInterface: BitFlag;
                soundVolume: BitFlag;
            }>, any>;
            doorClosedEvents: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    doorPositionSensor: boolean;
                }];
            };
            doorOpenEvents: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    doorPositionSensor: boolean;
                }];
            };
            doorState: Attribute<null | DoorLock.DoorState, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    doorPositionSensor: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            enableInsideStatusLed: OptionalWritableAttribute<boolean, any>;
            enableLocalProgramming: OptionalWritableAttribute<boolean, any>;
            enableLogging: WritableAttribute<boolean, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    logging: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            enableOneTouchLocking: OptionalWritableAttribute<boolean, any>;
            enablePrivacyModeButton: OptionalWritableAttribute<boolean, any>;
            expiringUserTimeout: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    user: boolean;
                }];
            };
            featureMap: Attribute<TypeFromPartialBitSchema<{
                credentialOverTheAirAccess: BitFlag;
                doorPositionSensor: BitFlag;
                faceCredentials: BitFlag;
                fingerCredentials: BitFlag;
                holidaySchedules: BitFlag;
                logging: BitFlag;
                notification: BitFlag;
                pinCredential: BitFlag;
                rfidCredential: BitFlag;
                unbolting: BitFlag;
                user: BitFlag;
                weekDayAccessSchedules: BitFlag;
                yearDayAccessSchedules: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            keypadOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                bit0: BitFlag;
                bit1: BitFlag;
                bit10: BitFlag;
                bit11: BitFlag;
                bit12: BitFlag;
                bit13: BitFlag;
                bit14: BitFlag;
                bit15: BitFlag;
                bit2: BitFlag;
                bit3: BitFlag;
                bit4: BitFlag;
                bit5: BitFlag;
                bit6: BitFlag;
                bit7: BitFlag;
                bit8: BitFlag;
                bit9: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                    pinCredential: boolean;
                }];
            };
            keypadProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                pinAdded: BitFlag;
                pinChanged: BitFlag;
                pinCleared: BitFlag;
                pinCodeChanged: BitFlag;
                unknown: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                    pinCredential: boolean;
                }];
            };
            language: OptionalWritableAttribute<string, any>;
            ledSettings: OptionalWritableAttribute<DoorLock.LedSetting, any>;
            localProgrammingFeatures: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                addUsersCredentialsSchedules: BitFlag;
                adjustSettings: BitFlag;
                clearUsersCredentialsSchedules: BitFlag;
                modifyUsersCredentialsSchedules: BitFlag;
            }>, any>;
            lockState: Attribute<null | DoorLock.LockState, any>;
            lockType: Attribute<DoorLock.LockType, any>;
            manualOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                bit0: BitFlag;
                bit1: BitFlag;
                bit10: BitFlag;
                bit11: BitFlag;
                bit12: BitFlag;
                bit13: BitFlag;
                bit14: BitFlag;
                bit15: BitFlag;
                bit2: BitFlag;
                bit3: BitFlag;
                bit4: BitFlag;
                bit5: BitFlag;
                bit6: BitFlag;
                bit7: BitFlag;
                bit8: BitFlag;
                bit9: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                }];
            };
            maxPinCodeLength: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            maxRfidCodeLength: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minPinCodeLength: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minRfidCodeLength: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfCredentialsSupportedPerUser: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfHolidaySchedulesSupported: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    holidaySchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfLogRecordsSupported: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    logging: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfPinUsersSupported: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfRfidUsersSupported: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfTotalUsersSupported: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfWeekDaySchedulesSupportedPerUser: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    weekDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfYearDaySchedulesSupportedPerUser: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    yearDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            openPeriod: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    doorPositionSensor: boolean;
                }];
            };
            operatingMode: WritableAttribute<DoorLock.OperatingMode, any>;
            remoteOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                bit0: BitFlag;
                bit1: BitFlag;
                bit10: BitFlag;
                bit11: BitFlag;
                bit12: BitFlag;
                bit13: BitFlag;
                bit14: BitFlag;
                bit15: BitFlag;
                bit2: BitFlag;
                bit3: BitFlag;
                bit4: BitFlag;
                bit5: BitFlag;
                bit6: BitFlag;
                bit7: BitFlag;
                bit8: BitFlag;
                bit9: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                }];
            };
            remoteProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                pinAdded: BitFlag;
                pinChanged: BitFlag;
                pinCleared: BitFlag;
                rfidCodeAdded: BitFlag;
                rfidCodeCleared: BitFlag;
                unknown: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                }];
            };
            requirePinForRemoteOperation: WritableAttribute<boolean, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    credentialOverTheAirAccess: boolean;
                    pinCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            rfidOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                bit0: BitFlag;
                bit1: BitFlag;
                bit10: BitFlag;
                bit11: BitFlag;
                bit12: BitFlag;
                bit13: BitFlag;
                bit14: BitFlag;
                bit15: BitFlag;
                bit2: BitFlag;
                bit3: BitFlag;
                bit4: BitFlag;
                bit5: BitFlag;
                bit6: BitFlag;
                bit7: BitFlag;
                bit8: BitFlag;
                bit9: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                    rfidCredential: boolean;
                }];
            };
            rfidProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                idAdded: BitFlag;
                idCleared: BitFlag;
                unknown: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                    rfidCredential: boolean;
                }];
            };
            sendPinOverTheAir: OptionalWritableAttribute<boolean, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    pinCredential: boolean;
                    user: boolean;
                }];
            };
            soundVolume: OptionalWritableAttribute<DoorLock.SoundVolume, any>;
            supportedOperatingModes: FixedAttribute<TypeFromPartialBitSchema<{
                noRemoteLockUnlock: BitFlag;
                normal: BitFlag;
                passage: BitFlag;
                privacy: BitFlag;
                vacation: BitFlag;
            }>, any>;
            userCodeTemporaryDisableTime: WritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                }, {
                    rfidCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            wrongCodeEntryLimit: WritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                }, {
                    rfidCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            clearAllPinCodes: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearAllRfidCodes: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearCredential: Command<TypeFromFields<{
                credential: FieldType<null | TypeFromFields<(...)>>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearHolidaySchedule: Command<TypeFromFields<{
                holidayIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    holidaySchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearPinCode: Command<TypeFromFields<{
                pinSlotIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearRfidCode: Command<TypeFromFields<{
                rfidSlotIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearUser: Command<TypeFromFields<{
                userIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearWeekDaySchedule: Command<TypeFromFields<{
                userIndexUserId: FieldType<number>;
                weekDayIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    weekDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearYearDaySchedule: Command<TypeFromFields<{
                userIndexUserId: FieldType<number>;
                yearDayIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    yearDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getCredentialStatus: Command<TypeFromFields<{
                credential: FieldType<TypeFromFields<{
                    credentialIndex: ...;
                    credentialType: ...;
                }>>;
            }>, TypeFromFields<{
                creatorFabricIndex: FieldType<null | FabricIndex>;
                credentialExists: FieldType<boolean>;
                lastModifiedFabricIndex: FieldType<null | FabricIndex>;
                nextCredentialIndex: OptionalFieldType<null | number>;
                userIndex: FieldType<null | number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getHolidaySchedule: Command<TypeFromFields<{
                holidayIndex: FieldType<number>;
            }>, TypeFromFields<{
                holidayIndex: FieldType<number>;
                localEndTime: OptionalFieldType<null | number>;
                localStartTime: OptionalFieldType<null | number>;
                operatingMode: OptionalFieldType<null | DoorLock.OperatingMode>;
                status: FieldType<Status>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    holidaySchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getLogRecord: Command<TypeFromFields<{
                logIndex: FieldType<number>;
            }>, TypeFromFields<{
                eventId: FieldType<number>;
                eventType: FieldType<DoorLock.EventType>;
                logEntryId: FieldType<number>;
                pin: FieldType<Uint8Array>;
                source: FieldType<DoorLock.EventSource>;
                timestamp: FieldType<number>;
                userId: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    logging: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getPinCode: Command<TypeFromFields<{
                userId: FieldType<number>;
            }>, TypeFromFields<{
                pinCode: FieldType<null | Uint8Array>;
                userId: FieldType<number>;
                userStatus: FieldType<null | DoorLock.UserStatus>;
                userType: FieldType<null | DoorLock.UserType>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getRfidCode: Command<TypeFromFields<{
                userId: FieldType<number>;
            }>, TypeFromFields<{
                rfidCode: FieldType<null | Uint8Array>;
                userId: FieldType<number>;
                userStatus: FieldType<null | DoorLock.UserStatus>;
                userType: FieldType<null | DoorLock.UserType>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getUser: Command<TypeFromFields<{
                userIndex: FieldType<number>;
            }>, TypeFromFields<{
                creatorFabricIndex: FieldType<null | FabricIndex>;
                credentialRule: FieldType<null | DoorLock.CredentialRule>;
                credentials: FieldType<null | (...)[]>;
                lastModifiedFabricIndex: FieldType<null | FabricIndex>;
                nextUserIndex: FieldType<null | number>;
                userIndex: FieldType<number>;
                userName: FieldType<null | string>;
                userStatus: FieldType<null | DoorLock.UserStatus>;
                userType: FieldType<null | DoorLock.UserType>;
                userUniqueId: FieldType<null | number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getUserStatus: OptionalCommand<TypeFromFields<{
                userId: FieldType<number>;
            }>, TypeFromFields<{
                userId: FieldType<number>;
                userStatus: FieldType<DoorLock.UserStatus>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    fingerCredentials: boolean;
                    pinCredential: boolean;
                    rfidCredential: boolean;
                    user: boolean;
                }];
            };
            getUserType: OptionalCommand<TypeFromFields<{
                userId: FieldType<number>;
            }>, TypeFromFields<{
                userId: FieldType<number>;
                userType: FieldType<DoorLock.UserType>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    fingerCredentials: boolean;
                    pinCredential: boolean;
                    rfidCredential: boolean;
                    user: boolean;
                }];
            };
            getWeekDaySchedule: Command<TypeFromFields<{
                userIndexUserId: FieldType<number>;
                weekDayIndex: FieldType<number>;
            }>, TypeFromFields<{
                daysMask: OptionalFieldType<TypeFromPartialBitSchema<{
                    friday: ...;
                    monday: ...;
                    saturday: ...;
                    sunday: ...;
                    thursday: ...;
                    tuesday: ...;
                    wednesday: ...;
                }>>;
                endHour: OptionalFieldType<number>;
                endMinute: OptionalFieldType<number>;
                startHour: OptionalFieldType<number>;
                startMinute: OptionalFieldType<number>;
                status: FieldType<Status>;
                userIndexUserId: FieldType<number>;
                weekDayIndex: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    weekDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getYearDaySchedule: Command<TypeFromFields<{
                userIndexUserId: FieldType<number>;
                yearDayIndex: FieldType<number>;
            }>, TypeFromFields<{
                localEndTime: OptionalFieldType<number>;
                localStartTime: OptionalFieldType<number>;
                status: FieldType<Status>;
                userIndexUserId: FieldType<number>;
                yearDayIndex: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    yearDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            lockDoor: Command<TypeFromFields<{
                pinCode: OptionalFieldType<Uint8Array>;
            }>, void, any>;
            setCredential: Command<TypeFromFields<{
                credential: FieldType<TypeFromFields<{
                    credentialIndex: ...;
                    credentialType: ...;
                }>>;
                credentialData: FieldType<Uint8Array>;
                operationType: FieldType<DoorLock.DataOperationType>;
                userIndex: FieldType<null | number>;
                userStatus: FieldType<null | DoorLock.UserStatus>;
                userType: FieldType<null | DoorLock.UserType>;
            }>, TypeFromFields<{
                nextCredentialIndex: OptionalFieldType<null | number>;
                status: FieldType<Status>;
                userIndex: FieldType<null | number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setHolidaySchedule: Command<TypeFromFields<{
                holidayIndex: FieldType<number>;
                localEndTime: FieldType<number>;
                localStartTime: FieldType<number>;
                operatingMode: FieldType<DoorLock.OperatingMode>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    holidaySchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setPinCode: Command<TypeFromFields<{
                pin: FieldType<Uint8Array>;
                userId: FieldType<number>;
                userStatus: FieldType<null | DoorLock.UserStatus>;
                userType: FieldType<null | DoorLock.UserType>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setRfidCode: Command<TypeFromFields<{
                rfidCode: FieldType<Uint8Array>;
                userId: FieldType<number>;
                userStatus: FieldType<null | DoorLock.UserStatus>;
                userType: FieldType<null | DoorLock.UserType>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setUser: Command<TypeFromFields<{
                credentialRule: FieldType<null | DoorLock.CredentialRule>;
                operationType: FieldType<DoorLock.DataOperationType>;
                userIndex: FieldType<number>;
                userName: FieldType<null | string>;
                userStatus: FieldType<null | DoorLock.UserStatus>;
                userType: FieldType<null | DoorLock.UserType>;
                userUniqueId: FieldType<null | number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setUserStatus: OptionalCommand<TypeFromFields<{
                userId: FieldType<number>;
                userStatus: FieldType<DoorLock.UserStatus>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    fingerCredentials: boolean;
                    pinCredential: boolean;
                    rfidCredential: boolean;
                    user: boolean;
                }];
            };
            setUserType: OptionalCommand<TypeFromFields<{
                userId: FieldType<number>;
                userType: FieldType<DoorLock.UserType>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    fingerCredentials: boolean;
                    pinCredential: boolean;
                    rfidCredential: boolean;
                    user: boolean;
                }];
            };
            setWeekDaySchedule: Command<TypeFromFields<{
                daysMask: FieldType<TypeFromPartialBitSchema<{
                    friday: ...;
                    monday: ...;
                    saturday: ...;
                    sunday: ...;
                    thursday: ...;
                    tuesday: ...;
                    wednesday: ...;
                }>>;
                endHour: FieldType<number>;
                endMinute: FieldType<number>;
                startHour: FieldType<number>;
                startMinute: FieldType<number>;
                userIndexUserId: FieldType<number>;
                weekDayIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    weekDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setYearDaySchedule: Command<TypeFromFields<{
                localEndTime: FieldType<number>;
                localStartTime: FieldType<number>;
                userIndexUserId: FieldType<number>;
                yearDayIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    yearDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            unboltDoor: Command<TypeFromFields<{
                pinCode: OptionalFieldType<Uint8Array>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    unbolting: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            unlockDoor: Command<TypeFromFields<{
                pinCode: OptionalFieldType<Uint8Array>;
            }>, void, any>;
            unlockWithTimeout: OptionalCommand<TypeFromFields<{
                pinCode: OptionalFieldType<Uint8Array>;
                timeout: FieldType<number>;
            }>, void, any>;
        };
        events: {
            doorLockAlarm: Event<TypeFromFields<{
                alarmCode: FieldType<DoorLock.AlarmCode>;
            }>, any>;
            doorStateChange: Event<TypeFromFields<{
                doorState: FieldType<DoorLock.DoorState>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    doorPositionSensor: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            lockOperation: Event<TypeFromFields<{
                credentials: OptionalFieldType<null | TypeFromFields<(...)>[]>;
                fabricIndex: FieldType<null | FabricIndex>;
                lockOperationType: FieldType<DoorLock.LockOperationType>;
                operationSource: FieldType<DoorLock.OperationSource>;
                sourceNode: FieldType<null | NodeId>;
                userIndex: FieldType<null | number>;
            }>, any>;
            lockOperationError: Event<TypeFromFields<{
                credentials: OptionalFieldType<null | TypeFromFields<(...)>[]>;
                fabricIndex: FieldType<null | FabricIndex>;
                lockOperationType: FieldType<DoorLock.LockOperationType>;
                operationError: FieldType<DoorLock.OperationError>;
                operationSource: FieldType<DoorLock.OperationSource>;
                sourceNode: FieldType<null | NodeId>;
                userIndex: FieldType<null | number>;
            }>, any>;
            lockUserChange: Event<TypeFromFields<{
                dataIndex: FieldType<null | number>;
                dataOperationType: FieldType<DoorLock.DataOperationType>;
                fabricIndex: FieldType<null | FabricIndex>;
                lockDataType: FieldType<DoorLock.LockDataType>;
                operationSource: FieldType<DoorLock.OperationSource>;
                sourceNode: FieldType<null | NodeId>;
                userIndex: FieldType<null | number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            credentialOverTheAirAccess: BitFlag;
            doorPositionSensor: BitFlag;
            faceCredentials: BitFlag;
            fingerCredentials: BitFlag;
            holidaySchedules: BitFlag;
            logging: BitFlag;
            notification: BitFlag;
            pinCredential: BitFlag;
            rfidCredential: BitFlag;
            unbolting: BitFlag;
            user: BitFlag;
            weekDayAccessSchedules: BitFlag;
            yearDayAccessSchedules: BitFlag;
        };
        id: Branded<257, "ClusterId">;
        name: "DoorLock";
        revision: 7;
    }>, FlagsT>;
    set<const ValuesT>(values: ValuesT): WithValues<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            actuatorEnabled: Attribute<boolean, any>;
            alarmMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                doorForcedOpen: BitFlag;
                frontEscutcheonRemoved: BitFlag;
                lockFactoryReset: BitFlag;
                lockJammed: BitFlag;
                lockRadioPowerCycled: BitFlag;
                na: BitFlag;
                wrongCodeEntryLimit: BitFlag;
            }>, any>;
            attributeList: Attribute<AttributeId[], never>;
            autoRelockTime: OptionalWritableAttribute<number, any>;
            clusterRevision: Attribute<number, never>;
            credentialRulesSupport: FixedAttribute<TypeFromPartialBitSchema<{
                dual: BitFlag;
                single: BitFlag;
                tri: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            defaultConfigurationRegister: OptionalAttribute<TypeFromPartialBitSchema<{
                autoRelockTime: BitFlag;
                keypadInterface: BitFlag;
                ledSettings: BitFlag;
                localProgramming: BitFlag;
                remoteInterface: BitFlag;
                soundVolume: BitFlag;
            }>, any>;
            doorClosedEvents: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    doorPositionSensor: boolean;
                }];
            };
            doorOpenEvents: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    doorPositionSensor: boolean;
                }];
            };
            doorState: Attribute<null | DoorLock.DoorState, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    doorPositionSensor: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            enableInsideStatusLed: OptionalWritableAttribute<boolean, any>;
            enableLocalProgramming: OptionalWritableAttribute<boolean, any>;
            enableLogging: WritableAttribute<boolean, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    logging: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            enableOneTouchLocking: OptionalWritableAttribute<boolean, any>;
            enablePrivacyModeButton: OptionalWritableAttribute<boolean, any>;
            expiringUserTimeout: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    user: boolean;
                }];
            };
            featureMap: Attribute<TypeFromPartialBitSchema<{
                credentialOverTheAirAccess: BitFlag;
                doorPositionSensor: BitFlag;
                faceCredentials: BitFlag;
                fingerCredentials: BitFlag;
                holidaySchedules: BitFlag;
                logging: BitFlag;
                notification: BitFlag;
                pinCredential: BitFlag;
                rfidCredential: BitFlag;
                unbolting: BitFlag;
                user: BitFlag;
                weekDayAccessSchedules: BitFlag;
                yearDayAccessSchedules: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            keypadOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                bit0: BitFlag;
                bit1: BitFlag;
                bit10: BitFlag;
                bit11: BitFlag;
                bit12: BitFlag;
                bit13: BitFlag;
                bit14: BitFlag;
                bit15: BitFlag;
                bit2: BitFlag;
                bit3: BitFlag;
                bit4: BitFlag;
                bit5: BitFlag;
                bit6: BitFlag;
                bit7: BitFlag;
                bit8: BitFlag;
                bit9: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                    pinCredential: boolean;
                }];
            };
            keypadProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                pinAdded: BitFlag;
                pinChanged: BitFlag;
                pinCleared: BitFlag;
                pinCodeChanged: BitFlag;
                unknown: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                    pinCredential: boolean;
                }];
            };
            language: OptionalWritableAttribute<string, any>;
            ledSettings: OptionalWritableAttribute<DoorLock.LedSetting, any>;
            localProgrammingFeatures: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                addUsersCredentialsSchedules: BitFlag;
                adjustSettings: BitFlag;
                clearUsersCredentialsSchedules: BitFlag;
                modifyUsersCredentialsSchedules: BitFlag;
            }>, any>;
            lockState: Attribute<null | DoorLock.LockState, any>;
            lockType: Attribute<DoorLock.LockType, any>;
            manualOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                bit0: BitFlag;
                bit1: BitFlag;
                bit10: BitFlag;
                bit11: BitFlag;
                bit12: BitFlag;
                bit13: BitFlag;
                bit14: BitFlag;
                bit15: BitFlag;
                bit2: BitFlag;
                bit3: BitFlag;
                bit4: BitFlag;
                bit5: BitFlag;
                bit6: BitFlag;
                bit7: BitFlag;
                bit8: BitFlag;
                bit9: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                }];
            };
            maxPinCodeLength: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            maxRfidCodeLength: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minPinCodeLength: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minRfidCodeLength: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfCredentialsSupportedPerUser: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfHolidaySchedulesSupported: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    holidaySchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfLogRecordsSupported: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    logging: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfPinUsersSupported: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfRfidUsersSupported: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfTotalUsersSupported: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfWeekDaySchedulesSupportedPerUser: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    weekDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfYearDaySchedulesSupportedPerUser: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    yearDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            openPeriod: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    doorPositionSensor: boolean;
                }];
            };
            operatingMode: WritableAttribute<DoorLock.OperatingMode, any>;
            remoteOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                bit0: BitFlag;
                bit1: BitFlag;
                bit10: BitFlag;
                bit11: BitFlag;
                bit12: BitFlag;
                bit13: BitFlag;
                bit14: BitFlag;
                bit15: BitFlag;
                bit2: BitFlag;
                bit3: BitFlag;
                bit4: BitFlag;
                bit5: BitFlag;
                bit6: BitFlag;
                bit7: BitFlag;
                bit8: BitFlag;
                bit9: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                }];
            };
            remoteProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                pinAdded: BitFlag;
                pinChanged: BitFlag;
                pinCleared: BitFlag;
                rfidCodeAdded: BitFlag;
                rfidCodeCleared: BitFlag;
                unknown: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                }];
            };
            requirePinForRemoteOperation: WritableAttribute<boolean, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    credentialOverTheAirAccess: boolean;
                    pinCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            rfidOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                bit0: BitFlag;
                bit1: BitFlag;
                bit10: BitFlag;
                bit11: BitFlag;
                bit12: BitFlag;
                bit13: BitFlag;
                bit14: BitFlag;
                bit15: BitFlag;
                bit2: BitFlag;
                bit3: BitFlag;
                bit4: BitFlag;
                bit5: BitFlag;
                bit6: BitFlag;
                bit7: BitFlag;
                bit8: BitFlag;
                bit9: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                    rfidCredential: boolean;
                }];
            };
            rfidProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                idAdded: BitFlag;
                idCleared: BitFlag;
                unknown: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                    rfidCredential: boolean;
                }];
            };
            sendPinOverTheAir: OptionalWritableAttribute<boolean, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    pinCredential: boolean;
                    user: boolean;
                }];
            };
            soundVolume: OptionalWritableAttribute<DoorLock.SoundVolume, any>;
            supportedOperatingModes: FixedAttribute<TypeFromPartialBitSchema<{
                noRemoteLockUnlock: BitFlag;
                normal: BitFlag;
                passage: BitFlag;
                privacy: BitFlag;
                vacation: BitFlag;
            }>, any>;
            userCodeTemporaryDisableTime: WritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                }, {
                    rfidCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            wrongCodeEntryLimit: WritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                }, {
                    rfidCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            clearAllPinCodes: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearAllRfidCodes: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearCredential: Command<TypeFromFields<{
                credential: FieldType<null | TypeFromFields<(...)>>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearHolidaySchedule: Command<TypeFromFields<{
                holidayIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    holidaySchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearPinCode: Command<TypeFromFields<{
                pinSlotIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearRfidCode: Command<TypeFromFields<{
                rfidSlotIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearUser: Command<TypeFromFields<{
                userIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearWeekDaySchedule: Command<TypeFromFields<{
                userIndexUserId: FieldType<number>;
                weekDayIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    weekDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearYearDaySchedule: Command<TypeFromFields<{
                userIndexUserId: FieldType<number>;
                yearDayIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    yearDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getCredentialStatus: Command<TypeFromFields<{
                credential: FieldType<TypeFromFields<{
                    credentialIndex: ...;
                    credentialType: ...;
                }>>;
            }>, TypeFromFields<{
                creatorFabricIndex: FieldType<null | FabricIndex>;
                credentialExists: FieldType<boolean>;
                lastModifiedFabricIndex: FieldType<null | FabricIndex>;
                nextCredentialIndex: OptionalFieldType<null | number>;
                userIndex: FieldType<null | number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getHolidaySchedule: Command<TypeFromFields<{
                holidayIndex: FieldType<number>;
            }>, TypeFromFields<{
                holidayIndex: FieldType<number>;
                localEndTime: OptionalFieldType<null | number>;
                localStartTime: OptionalFieldType<null | number>;
                operatingMode: OptionalFieldType<null | DoorLock.OperatingMode>;
                status: FieldType<Status>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    holidaySchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getLogRecord: Command<TypeFromFields<{
                logIndex: FieldType<number>;
            }>, TypeFromFields<{
                eventId: FieldType<number>;
                eventType: FieldType<DoorLock.EventType>;
                logEntryId: FieldType<number>;
                pin: FieldType<Uint8Array>;
                source: FieldType<DoorLock.EventSource>;
                timestamp: FieldType<number>;
                userId: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    logging: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getPinCode: Command<TypeFromFields<{
                userId: FieldType<number>;
            }>, TypeFromFields<{
                pinCode: FieldType<null | Uint8Array>;
                userId: FieldType<number>;
                userStatus: FieldType<null | DoorLock.UserStatus>;
                userType: FieldType<null | DoorLock.UserType>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getRfidCode: Command<TypeFromFields<{
                userId: FieldType<number>;
            }>, TypeFromFields<{
                rfidCode: FieldType<null | Uint8Array>;
                userId: FieldType<number>;
                userStatus: FieldType<null | DoorLock.UserStatus>;
                userType: FieldType<null | DoorLock.UserType>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getUser: Command<TypeFromFields<{
                userIndex: FieldType<number>;
            }>, TypeFromFields<{
                creatorFabricIndex: FieldType<null | FabricIndex>;
                credentialRule: FieldType<null | DoorLock.CredentialRule>;
                credentials: FieldType<null | (...)[]>;
                lastModifiedFabricIndex: FieldType<null | FabricIndex>;
                nextUserIndex: FieldType<null | number>;
                userIndex: FieldType<number>;
                userName: FieldType<null | string>;
                userStatus: FieldType<null | DoorLock.UserStatus>;
                userType: FieldType<null | DoorLock.UserType>;
                userUniqueId: FieldType<null | number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getUserStatus: OptionalCommand<TypeFromFields<{
                userId: FieldType<number>;
            }>, TypeFromFields<{
                userId: FieldType<number>;
                userStatus: FieldType<DoorLock.UserStatus>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    fingerCredentials: boolean;
                    pinCredential: boolean;
                    rfidCredential: boolean;
                    user: boolean;
                }];
            };
            getUserType: OptionalCommand<TypeFromFields<{
                userId: FieldType<number>;
            }>, TypeFromFields<{
                userId: FieldType<number>;
                userType: FieldType<DoorLock.UserType>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    fingerCredentials: boolean;
                    pinCredential: boolean;
                    rfidCredential: boolean;
                    user: boolean;
                }];
            };
            getWeekDaySchedule: Command<TypeFromFields<{
                userIndexUserId: FieldType<number>;
                weekDayIndex: FieldType<number>;
            }>, TypeFromFields<{
                daysMask: OptionalFieldType<TypeFromPartialBitSchema<{
                    friday: ...;
                    monday: ...;
                    saturday: ...;
                    sunday: ...;
                    thursday: ...;
                    tuesday: ...;
                    wednesday: ...;
                }>>;
                endHour: OptionalFieldType<number>;
                endMinute: OptionalFieldType<number>;
                startHour: OptionalFieldType<number>;
                startMinute: OptionalFieldType<number>;
                status: FieldType<Status>;
                userIndexUserId: FieldType<number>;
                weekDayIndex: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    weekDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getYearDaySchedule: Command<TypeFromFields<{
                userIndexUserId: FieldType<number>;
                yearDayIndex: FieldType<number>;
            }>, TypeFromFields<{
                localEndTime: OptionalFieldType<number>;
                localStartTime: OptionalFieldType<number>;
                status: FieldType<Status>;
                userIndexUserId: FieldType<number>;
                yearDayIndex: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    yearDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            lockDoor: Command<TypeFromFields<{
                pinCode: OptionalFieldType<Uint8Array>;
            }>, void, any>;
            setCredential: Command<TypeFromFields<{
                credential: FieldType<TypeFromFields<{
                    credentialIndex: ...;
                    credentialType: ...;
                }>>;
                credentialData: FieldType<Uint8Array>;
                operationType: FieldType<DoorLock.DataOperationType>;
                userIndex: FieldType<null | number>;
                userStatus: FieldType<null | DoorLock.UserStatus>;
                userType: FieldType<null | DoorLock.UserType>;
            }>, TypeFromFields<{
                nextCredentialIndex: OptionalFieldType<null | number>;
                status: FieldType<Status>;
                userIndex: FieldType<null | number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setHolidaySchedule: Command<TypeFromFields<{
                holidayIndex: FieldType<number>;
                localEndTime: FieldType<number>;
                localStartTime: FieldType<number>;
                operatingMode: FieldType<DoorLock.OperatingMode>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    holidaySchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setPinCode: Command<TypeFromFields<{
                pin: FieldType<Uint8Array>;
                userId: FieldType<number>;
                userStatus: FieldType<null | DoorLock.UserStatus>;
                userType: FieldType<null | DoorLock.UserType>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setRfidCode: Command<TypeFromFields<{
                rfidCode: FieldType<Uint8Array>;
                userId: FieldType<number>;
                userStatus: FieldType<null | DoorLock.UserStatus>;
                userType: FieldType<null | DoorLock.UserType>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setUser: Command<TypeFromFields<{
                credentialRule: FieldType<null | DoorLock.CredentialRule>;
                operationType: FieldType<DoorLock.DataOperationType>;
                userIndex: FieldType<number>;
                userName: FieldType<null | string>;
                userStatus: FieldType<null | DoorLock.UserStatus>;
                userType: FieldType<null | DoorLock.UserType>;
                userUniqueId: FieldType<null | number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setUserStatus: OptionalCommand<TypeFromFields<{
                userId: FieldType<number>;
                userStatus: FieldType<DoorLock.UserStatus>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    fingerCredentials: boolean;
                    pinCredential: boolean;
                    rfidCredential: boolean;
                    user: boolean;
                }];
            };
            setUserType: OptionalCommand<TypeFromFields<{
                userId: FieldType<number>;
                userType: FieldType<DoorLock.UserType>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    fingerCredentials: boolean;
                    pinCredential: boolean;
                    rfidCredential: boolean;
                    user: boolean;
                }];
            };
            setWeekDaySchedule: Command<TypeFromFields<{
                daysMask: FieldType<TypeFromPartialBitSchema<{
                    friday: ...;
                    monday: ...;
                    saturday: ...;
                    sunday: ...;
                    thursday: ...;
                    tuesday: ...;
                    wednesday: ...;
                }>>;
                endHour: FieldType<number>;
                endMinute: FieldType<number>;
                startHour: FieldType<number>;
                startMinute: FieldType<number>;
                userIndexUserId: FieldType<number>;
                weekDayIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    weekDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setYearDaySchedule: Command<TypeFromFields<{
                localEndTime: FieldType<number>;
                localStartTime: FieldType<number>;
                userIndexUserId: FieldType<number>;
                yearDayIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    yearDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            unboltDoor: Command<TypeFromFields<{
                pinCode: OptionalFieldType<Uint8Array>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    unbolting: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            unlockDoor: Command<TypeFromFields<{
                pinCode: OptionalFieldType<Uint8Array>;
            }>, void, any>;
            unlockWithTimeout: OptionalCommand<TypeFromFields<{
                pinCode: OptionalFieldType<Uint8Array>;
                timeout: FieldType<number>;
            }>, void, any>;
        };
        events: {
            doorLockAlarm: Event<TypeFromFields<{
                alarmCode: FieldType<DoorLock.AlarmCode>;
            }>, any>;
            doorStateChange: Event<TypeFromFields<{
                doorState: FieldType<DoorLock.DoorState>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    doorPositionSensor: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            lockOperation: Event<TypeFromFields<{
                credentials: OptionalFieldType<null | TypeFromFields<(...)>[]>;
                fabricIndex: FieldType<null | FabricIndex>;
                lockOperationType: FieldType<DoorLock.LockOperationType>;
                operationSource: FieldType<DoorLock.OperationSource>;
                sourceNode: FieldType<null | NodeId>;
                userIndex: FieldType<null | number>;
            }>, any>;
            lockOperationError: Event<TypeFromFields<{
                credentials: OptionalFieldType<null | TypeFromFields<(...)>[]>;
                fabricIndex: FieldType<null | FabricIndex>;
                lockOperationType: FieldType<DoorLock.LockOperationType>;
                operationError: FieldType<DoorLock.OperationError>;
                operationSource: FieldType<DoorLock.OperationSource>;
                sourceNode: FieldType<null | NodeId>;
                userIndex: FieldType<null | number>;
            }>, any>;
            lockUserChange: Event<TypeFromFields<{
                dataIndex: FieldType<null | number>;
                dataOperationType: FieldType<DoorLock.DataOperationType>;
                fabricIndex: FieldType<null | FabricIndex>;
                lockDataType: FieldType<DoorLock.LockDataType>;
                operationSource: FieldType<DoorLock.OperationSource>;
                sourceNode: FieldType<null | NodeId>;
                userIndex: FieldType<null | number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            credentialOverTheAirAccess: BitFlag;
            doorPositionSensor: BitFlag;
            faceCredentials: BitFlag;
            fingerCredentials: BitFlag;
            holidaySchedules: BitFlag;
            logging: BitFlag;
            notification: BitFlag;
            pinCredential: BitFlag;
            rfidCredential: BitFlag;
            unbolting: BitFlag;
            user: BitFlag;
            weekDayAccessSchedules: BitFlag;
            yearDayAccessSchedules: BitFlag;
        };
        id: Branded<257, "ClusterId">;
        name: "DoorLock";
        revision: 7;
    }>, ValuesT>;
    with<const SelectionT>(...selection: SelectionT): Of<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            actuatorEnabled: Attribute<boolean, any>;
            alarmMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                doorForcedOpen: BitFlag;
                frontEscutcheonRemoved: BitFlag;
                lockFactoryReset: BitFlag;
                lockJammed: BitFlag;
                lockRadioPowerCycled: BitFlag;
                na: BitFlag;
                wrongCodeEntryLimit: BitFlag;
            }>, any>;
            attributeList: Attribute<AttributeId[], never>;
            autoRelockTime: OptionalWritableAttribute<number, any>;
            clusterRevision: Attribute<number, never>;
            credentialRulesSupport: FixedAttribute<TypeFromPartialBitSchema<{
                dual: BitFlag;
                single: BitFlag;
                tri: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            defaultConfigurationRegister: OptionalAttribute<TypeFromPartialBitSchema<{
                autoRelockTime: BitFlag;
                keypadInterface: BitFlag;
                ledSettings: BitFlag;
                localProgramming: BitFlag;
                remoteInterface: BitFlag;
                soundVolume: BitFlag;
            }>, any>;
            doorClosedEvents: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    doorPositionSensor: boolean;
                }];
            };
            doorOpenEvents: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    doorPositionSensor: boolean;
                }];
            };
            doorState: Attribute<null | DoorLock.DoorState, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    doorPositionSensor: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            enableInsideStatusLed: OptionalWritableAttribute<boolean, any>;
            enableLocalProgramming: OptionalWritableAttribute<boolean, any>;
            enableLogging: WritableAttribute<boolean, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    logging: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            enableOneTouchLocking: OptionalWritableAttribute<boolean, any>;
            enablePrivacyModeButton: OptionalWritableAttribute<boolean, any>;
            expiringUserTimeout: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    user: boolean;
                }];
            };
            featureMap: Attribute<TypeFromPartialBitSchema<{
                credentialOverTheAirAccess: BitFlag;
                doorPositionSensor: BitFlag;
                faceCredentials: BitFlag;
                fingerCredentials: BitFlag;
                holidaySchedules: BitFlag;
                logging: BitFlag;
                notification: BitFlag;
                pinCredential: BitFlag;
                rfidCredential: BitFlag;
                unbolting: BitFlag;
                user: BitFlag;
                weekDayAccessSchedules: BitFlag;
                yearDayAccessSchedules: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            keypadOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                bit0: BitFlag;
                bit1: BitFlag;
                bit10: BitFlag;
                bit11: BitFlag;
                bit12: BitFlag;
                bit13: BitFlag;
                bit14: BitFlag;
                bit15: BitFlag;
                bit2: BitFlag;
                bit3: BitFlag;
                bit4: BitFlag;
                bit5: BitFlag;
                bit6: BitFlag;
                bit7: BitFlag;
                bit8: BitFlag;
                bit9: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                    pinCredential: boolean;
                }];
            };
            keypadProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                pinAdded: BitFlag;
                pinChanged: BitFlag;
                pinCleared: BitFlag;
                pinCodeChanged: BitFlag;
                unknown: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                    pinCredential: boolean;
                }];
            };
            language: OptionalWritableAttribute<string, any>;
            ledSettings: OptionalWritableAttribute<DoorLock.LedSetting, any>;
            localProgrammingFeatures: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                addUsersCredentialsSchedules: BitFlag;
                adjustSettings: BitFlag;
                clearUsersCredentialsSchedules: BitFlag;
                modifyUsersCredentialsSchedules: BitFlag;
            }>, any>;
            lockState: Attribute<null | DoorLock.LockState, any>;
            lockType: Attribute<DoorLock.LockType, any>;
            manualOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                bit0: BitFlag;
                bit1: BitFlag;
                bit10: BitFlag;
                bit11: BitFlag;
                bit12: BitFlag;
                bit13: BitFlag;
                bit14: BitFlag;
                bit15: BitFlag;
                bit2: BitFlag;
                bit3: BitFlag;
                bit4: BitFlag;
                bit5: BitFlag;
                bit6: BitFlag;
                bit7: BitFlag;
                bit8: BitFlag;
                bit9: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                }];
            };
            maxPinCodeLength: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            maxRfidCodeLength: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minPinCodeLength: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minRfidCodeLength: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfCredentialsSupportedPerUser: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfHolidaySchedulesSupported: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    holidaySchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfLogRecordsSupported: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    logging: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfPinUsersSupported: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfRfidUsersSupported: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfTotalUsersSupported: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfWeekDaySchedulesSupportedPerUser: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    weekDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfYearDaySchedulesSupportedPerUser: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    yearDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            openPeriod: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    doorPositionSensor: boolean;
                }];
            };
            operatingMode: WritableAttribute<DoorLock.OperatingMode, any>;
            remoteOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                bit0: BitFlag;
                bit1: BitFlag;
                bit10: BitFlag;
                bit11: BitFlag;
                bit12: BitFlag;
                bit13: BitFlag;
                bit14: BitFlag;
                bit15: BitFlag;
                bit2: BitFlag;
                bit3: BitFlag;
                bit4: BitFlag;
                bit5: BitFlag;
                bit6: BitFlag;
                bit7: BitFlag;
                bit8: BitFlag;
                bit9: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                }];
            };
            remoteProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                pinAdded: BitFlag;
                pinChanged: BitFlag;
                pinCleared: BitFlag;
                rfidCodeAdded: BitFlag;
                rfidCodeCleared: BitFlag;
                unknown: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                }];
            };
            requirePinForRemoteOperation: WritableAttribute<boolean, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    credentialOverTheAirAccess: boolean;
                    pinCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            rfidOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                bit0: BitFlag;
                bit1: BitFlag;
                bit10: BitFlag;
                bit11: BitFlag;
                bit12: BitFlag;
                bit13: BitFlag;
                bit14: BitFlag;
                bit15: BitFlag;
                bit2: BitFlag;
                bit3: BitFlag;
                bit4: BitFlag;
                bit5: BitFlag;
                bit6: BitFlag;
                bit7: BitFlag;
                bit8: BitFlag;
                bit9: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                    rfidCredential: boolean;
                }];
            };
            rfidProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                idAdded: BitFlag;
                idCleared: BitFlag;
                unknown: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                    rfidCredential: boolean;
                }];
            };
            sendPinOverTheAir: OptionalWritableAttribute<boolean, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    pinCredential: boolean;
                    user: boolean;
                }];
            };
            soundVolume: OptionalWritableAttribute<DoorLock.SoundVolume, any>;
            supportedOperatingModes: FixedAttribute<TypeFromPartialBitSchema<{
                noRemoteLockUnlock: BitFlag;
                normal: BitFlag;
                passage: BitFlag;
                privacy: BitFlag;
                vacation: BitFlag;
            }>, any>;
            userCodeTemporaryDisableTime: WritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                }, {
                    rfidCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            wrongCodeEntryLimit: WritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                }, {
                    rfidCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            clearAllPinCodes: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearAllRfidCodes: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearCredential: Command<TypeFromFields<{
                credential: FieldType<null | TypeFromFields<(...)>>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearHolidaySchedule: Command<TypeFromFields<{
                holidayIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    holidaySchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearPinCode: Command<TypeFromFields<{
                pinSlotIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearRfidCode: Command<TypeFromFields<{
                rfidSlotIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearUser: Command<TypeFromFields<{
                userIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearWeekDaySchedule: Command<TypeFromFields<{
                userIndexUserId: FieldType<number>;
                weekDayIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    weekDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearYearDaySchedule: Command<TypeFromFields<{
                userIndexUserId: FieldType<number>;
                yearDayIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    yearDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getCredentialStatus: Command<TypeFromFields<{
                credential: FieldType<TypeFromFields<{
                    credentialIndex: ...;
                    credentialType: ...;
                }>>;
            }>, TypeFromFields<{
                creatorFabricIndex: FieldType<null | FabricIndex>;
                credentialExists: FieldType<boolean>;
                lastModifiedFabricIndex: FieldType<null | FabricIndex>;
                nextCredentialIndex: OptionalFieldType<null | number>;
                userIndex: FieldType<null | number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getHolidaySchedule: Command<TypeFromFields<{
                holidayIndex: FieldType<number>;
            }>, TypeFromFields<{
                holidayIndex: FieldType<number>;
                localEndTime: OptionalFieldType<null | number>;
                localStartTime: OptionalFieldType<null | number>;
                operatingMode: OptionalFieldType<null | DoorLock.OperatingMode>;
                status: FieldType<Status>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    holidaySchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getLogRecord: Command<TypeFromFields<{
                logIndex: FieldType<number>;
            }>, TypeFromFields<{
                eventId: FieldType<number>;
                eventType: FieldType<DoorLock.EventType>;
                logEntryId: FieldType<number>;
                pin: FieldType<Uint8Array>;
                source: FieldType<DoorLock.EventSource>;
                timestamp: FieldType<number>;
                userId: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    logging: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getPinCode: Command<TypeFromFields<{
                userId: FieldType<number>;
            }>, TypeFromFields<{
                pinCode: FieldType<null | Uint8Array>;
                userId: FieldType<number>;
                userStatus: FieldType<null | DoorLock.UserStatus>;
                userType: FieldType<null | DoorLock.UserType>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getRfidCode: Command<TypeFromFields<{
                userId: FieldType<number>;
            }>, TypeFromFields<{
                rfidCode: FieldType<null | Uint8Array>;
                userId: FieldType<number>;
                userStatus: FieldType<null | DoorLock.UserStatus>;
                userType: FieldType<null | DoorLock.UserType>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getUser: Command<TypeFromFields<{
                userIndex: FieldType<number>;
            }>, TypeFromFields<{
                creatorFabricIndex: FieldType<null | FabricIndex>;
                credentialRule: FieldType<null | DoorLock.CredentialRule>;
                credentials: FieldType<null | (...)[]>;
                lastModifiedFabricIndex: FieldType<null | FabricIndex>;
                nextUserIndex: FieldType<null | number>;
                userIndex: FieldType<number>;
                userName: FieldType<null | string>;
                userStatus: FieldType<null | DoorLock.UserStatus>;
                userType: FieldType<null | DoorLock.UserType>;
                userUniqueId: FieldType<null | number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getUserStatus: OptionalCommand<TypeFromFields<{
                userId: FieldType<number>;
            }>, TypeFromFields<{
                userId: FieldType<number>;
                userStatus: FieldType<DoorLock.UserStatus>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    fingerCredentials: boolean;
                    pinCredential: boolean;
                    rfidCredential: boolean;
                    user: boolean;
                }];
            };
            getUserType: OptionalCommand<TypeFromFields<{
                userId: FieldType<number>;
            }>, TypeFromFields<{
                userId: FieldType<number>;
                userType: FieldType<DoorLock.UserType>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    fingerCredentials: boolean;
                    pinCredential: boolean;
                    rfidCredential: boolean;
                    user: boolean;
                }];
            };
            getWeekDaySchedule: Command<TypeFromFields<{
                userIndexUserId: FieldType<number>;
                weekDayIndex: FieldType<number>;
            }>, TypeFromFields<{
                daysMask: OptionalFieldType<TypeFromPartialBitSchema<{
                    friday: ...;
                    monday: ...;
                    saturday: ...;
                    sunday: ...;
                    thursday: ...;
                    tuesday: ...;
                    wednesday: ...;
                }>>;
                endHour: OptionalFieldType<number>;
                endMinute: OptionalFieldType<number>;
                startHour: OptionalFieldType<number>;
                startMinute: OptionalFieldType<number>;
                status: FieldType<Status>;
                userIndexUserId: FieldType<number>;
                weekDayIndex: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    weekDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getYearDaySchedule: Command<TypeFromFields<{
                userIndexUserId: FieldType<number>;
                yearDayIndex: FieldType<number>;
            }>, TypeFromFields<{
                localEndTime: OptionalFieldType<number>;
                localStartTime: OptionalFieldType<number>;
                status: FieldType<Status>;
                userIndexUserId: FieldType<number>;
                yearDayIndex: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    yearDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            lockDoor: Command<TypeFromFields<{
                pinCode: OptionalFieldType<Uint8Array>;
            }>, void, any>;
            setCredential: Command<TypeFromFields<{
                credential: FieldType<TypeFromFields<{
                    credentialIndex: ...;
                    credentialType: ...;
                }>>;
                credentialData: FieldType<Uint8Array>;
                operationType: FieldType<DoorLock.DataOperationType>;
                userIndex: FieldType<null | number>;
                userStatus: FieldType<null | DoorLock.UserStatus>;
                userType: FieldType<null | DoorLock.UserType>;
            }>, TypeFromFields<{
                nextCredentialIndex: OptionalFieldType<null | number>;
                status: FieldType<Status>;
                userIndex: FieldType<null | number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setHolidaySchedule: Command<TypeFromFields<{
                holidayIndex: FieldType<number>;
                localEndTime: FieldType<number>;
                localStartTime: FieldType<number>;
                operatingMode: FieldType<DoorLock.OperatingMode>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    holidaySchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setPinCode: Command<TypeFromFields<{
                pin: FieldType<Uint8Array>;
                userId: FieldType<number>;
                userStatus: FieldType<null | DoorLock.UserStatus>;
                userType: FieldType<null | DoorLock.UserType>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setRfidCode: Command<TypeFromFields<{
                rfidCode: FieldType<Uint8Array>;
                userId: FieldType<number>;
                userStatus: FieldType<null | DoorLock.UserStatus>;
                userType: FieldType<null | DoorLock.UserType>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setUser: Command<TypeFromFields<{
                credentialRule: FieldType<null | DoorLock.CredentialRule>;
                operationType: FieldType<DoorLock.DataOperationType>;
                userIndex: FieldType<number>;
                userName: FieldType<null | string>;
                userStatus: FieldType<null | DoorLock.UserStatus>;
                userType: FieldType<null | DoorLock.UserType>;
                userUniqueId: FieldType<null | number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setUserStatus: OptionalCommand<TypeFromFields<{
                userId: FieldType<number>;
                userStatus: FieldType<DoorLock.UserStatus>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    fingerCredentials: boolean;
                    pinCredential: boolean;
                    rfidCredential: boolean;
                    user: boolean;
                }];
            };
            setUserType: OptionalCommand<TypeFromFields<{
                userId: FieldType<number>;
                userType: FieldType<DoorLock.UserType>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    fingerCredentials: boolean;
                    pinCredential: boolean;
                    rfidCredential: boolean;
                    user: boolean;
                }];
            };
            setWeekDaySchedule: Command<TypeFromFields<{
                daysMask: FieldType<TypeFromPartialBitSchema<{
                    friday: ...;
                    monday: ...;
                    saturday: ...;
                    sunday: ...;
                    thursday: ...;
                    tuesday: ...;
                    wednesday: ...;
                }>>;
                endHour: FieldType<number>;
                endMinute: FieldType<number>;
                startHour: FieldType<number>;
                startMinute: FieldType<number>;
                userIndexUserId: FieldType<number>;
                weekDayIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    weekDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setYearDaySchedule: Command<TypeFromFields<{
                localEndTime: FieldType<number>;
                localStartTime: FieldType<number>;
                userIndexUserId: FieldType<number>;
                yearDayIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    yearDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            unboltDoor: Command<TypeFromFields<{
                pinCode: OptionalFieldType<Uint8Array>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    unbolting: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            unlockDoor: Command<TypeFromFields<{
                pinCode: OptionalFieldType<Uint8Array>;
            }>, void, any>;
            unlockWithTimeout: OptionalCommand<TypeFromFields<{
                pinCode: OptionalFieldType<Uint8Array>;
                timeout: FieldType<number>;
            }>, void, any>;
        };
        events: {
            doorLockAlarm: Event<TypeFromFields<{
                alarmCode: FieldType<DoorLock.AlarmCode>;
            }>, any>;
            doorStateChange: Event<TypeFromFields<{
                doorState: FieldType<DoorLock.DoorState>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    doorPositionSensor: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            lockOperation: Event<TypeFromFields<{
                credentials: OptionalFieldType<null | TypeFromFields<(...)>[]>;
                fabricIndex: FieldType<null | FabricIndex>;
                lockOperationType: FieldType<DoorLock.LockOperationType>;
                operationSource: FieldType<DoorLock.OperationSource>;
                sourceNode: FieldType<null | NodeId>;
                userIndex: FieldType<null | number>;
            }>, any>;
            lockOperationError: Event<TypeFromFields<{
                credentials: OptionalFieldType<null | TypeFromFields<(...)>[]>;
                fabricIndex: FieldType<null | FabricIndex>;
                lockOperationType: FieldType<DoorLock.LockOperationType>;
                operationError: FieldType<DoorLock.OperationError>;
                operationSource: FieldType<DoorLock.OperationSource>;
                sourceNode: FieldType<null | NodeId>;
                userIndex: FieldType<null | number>;
            }>, any>;
            lockUserChange: Event<TypeFromFields<{
                dataIndex: FieldType<null | number>;
                dataOperationType: FieldType<DoorLock.DataOperationType>;
                fabricIndex: FieldType<null | FabricIndex>;
                lockDataType: FieldType<DoorLock.LockDataType>;
                operationSource: FieldType<DoorLock.OperationSource>;
                sourceNode: FieldType<null | NodeId>;
                userIndex: FieldType<null | number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            credentialOverTheAirAccess: BitFlag;
            doorPositionSensor: BitFlag;
            faceCredentials: BitFlag;
            fingerCredentials: BitFlag;
            holidaySchedules: BitFlag;
            logging: BitFlag;
            notification: BitFlag;
            pinCredential: BitFlag;
            rfidCredential: BitFlag;
            unbolting: BitFlag;
            user: BitFlag;
            weekDayAccessSchedules: BitFlag;
            yearDayAccessSchedules: BitFlag;
        };
        id: Branded<257, "ClusterId">;
        name: "DoorLock";
        revision: 7;
    }>, SelectionT>;
}

Hierarchy (view full)

Properties

attributes: Merge<{
    acceptedCommandList: Attribute<CommandId[], never>;
    actuatorEnabled: Attribute<boolean, any>;
    alarmMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
        doorForcedOpen: BitFlag;
        frontEscutcheonRemoved: BitFlag;
        lockFactoryReset: BitFlag;
        lockJammed: BitFlag;
        lockRadioPowerCycled: BitFlag;
        na: BitFlag;
        wrongCodeEntryLimit: BitFlag;
    }>, any>;
    attributeList: Attribute<AttributeId[], never>;
    autoRelockTime: OptionalWritableAttribute<number, any>;
    clusterRevision: Attribute<number, never>;
    credentialRulesSupport: FixedAttribute<TypeFromPartialBitSchema<{
        dual: BitFlag;
        single: BitFlag;
        tri: BitFlag;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            user: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    defaultConfigurationRegister: OptionalAttribute<TypeFromPartialBitSchema<{
        autoRelockTime: BitFlag;
        keypadInterface: BitFlag;
        ledSettings: BitFlag;
        localProgramming: BitFlag;
        remoteInterface: BitFlag;
        soundVolume: BitFlag;
    }>, any>;
    doorClosedEvents: OptionalWritableAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            doorPositionSensor: boolean;
        }];
    };
    doorOpenEvents: OptionalWritableAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            doorPositionSensor: boolean;
        }];
    };
    doorState: Attribute<null | DoorLock.DoorState, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            doorPositionSensor: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    enableInsideStatusLed: OptionalWritableAttribute<boolean, any>;
    enableLocalProgramming: OptionalWritableAttribute<boolean, any>;
    enableLogging: WritableAttribute<boolean, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            logging: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    enableOneTouchLocking: OptionalWritableAttribute<boolean, any>;
    enablePrivacyModeButton: OptionalWritableAttribute<boolean, any>;
    expiringUserTimeout: OptionalWritableAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            user: boolean;
        }];
    };
    featureMap: Attribute<TypeFromPartialBitSchema<{
        credentialOverTheAirAccess: BitFlag;
        doorPositionSensor: BitFlag;
        faceCredentials: BitFlag;
        fingerCredentials: BitFlag;
        holidaySchedules: BitFlag;
        logging: BitFlag;
        notification: BitFlag;
        pinCredential: BitFlag;
        rfidCredential: BitFlag;
        unbolting: BitFlag;
        user: BitFlag;
        weekDayAccessSchedules: BitFlag;
        yearDayAccessSchedules: BitFlag;
    }>, never>;
    generatedCommandList: Attribute<CommandId[], never>;
    keypadOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
        bit0: BitFlag;
        bit1: BitFlag;
        bit10: BitFlag;
        bit11: BitFlag;
        bit12: BitFlag;
        bit13: BitFlag;
        bit14: BitFlag;
        bit15: BitFlag;
        bit2: BitFlag;
        bit3: BitFlag;
        bit4: BitFlag;
        bit5: BitFlag;
        bit6: BitFlag;
        bit7: BitFlag;
        bit8: BitFlag;
        bit9: BitFlag;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            notification: boolean;
            pinCredential: boolean;
        }];
    };
    keypadProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
        pinAdded: BitFlag;
        pinChanged: BitFlag;
        pinCleared: BitFlag;
        pinCodeChanged: BitFlag;
        unknown: BitFlag;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            notification: boolean;
            pinCredential: boolean;
        }];
    };
    language: OptionalWritableAttribute<string, any>;
    ledSettings: OptionalWritableAttribute<DoorLock.LedSetting, any>;
    localProgrammingFeatures: OptionalWritableAttribute<TypeFromPartialBitSchema<{
        addUsersCredentialsSchedules: BitFlag;
        adjustSettings: BitFlag;
        clearUsersCredentialsSchedules: BitFlag;
        modifyUsersCredentialsSchedules: BitFlag;
    }>, any>;
    lockState: Attribute<null | DoorLock.LockState, any>;
    lockType: Attribute<DoorLock.LockType, any>;
    manualOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
        bit0: BitFlag;
        bit1: BitFlag;
        bit10: BitFlag;
        bit11: BitFlag;
        bit12: BitFlag;
        bit13: BitFlag;
        bit14: BitFlag;
        bit15: BitFlag;
        bit2: BitFlag;
        bit3: BitFlag;
        bit4: BitFlag;
        bit5: BitFlag;
        bit6: BitFlag;
        bit7: BitFlag;
        bit8: BitFlag;
        bit9: BitFlag;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            notification: boolean;
        }];
    };
    maxPinCodeLength: FixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            pinCredential: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    maxRfidCodeLength: FixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            rfidCredential: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    minPinCodeLength: FixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            pinCredential: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    minRfidCodeLength: FixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            rfidCredential: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    numberOfCredentialsSupportedPerUser: FixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            user: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    numberOfHolidaySchedulesSupported: FixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            holidaySchedules: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    numberOfLogRecordsSupported: FixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            logging: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    numberOfPinUsersSupported: FixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            pinCredential: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    numberOfRfidUsersSupported: FixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            rfidCredential: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    numberOfTotalUsersSupported: FixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            user: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    numberOfWeekDaySchedulesSupportedPerUser: FixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            weekDayAccessSchedules: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    numberOfYearDaySchedulesSupportedPerUser: FixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            yearDayAccessSchedules: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    openPeriod: OptionalWritableAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            doorPositionSensor: boolean;
        }];
    };
    operatingMode: WritableAttribute<DoorLock.OperatingMode, any>;
    remoteOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
        bit0: BitFlag;
        bit1: BitFlag;
        bit10: BitFlag;
        bit11: BitFlag;
        bit12: BitFlag;
        bit13: BitFlag;
        bit14: BitFlag;
        bit15: BitFlag;
        bit2: BitFlag;
        bit3: BitFlag;
        bit4: BitFlag;
        bit5: BitFlag;
        bit6: BitFlag;
        bit7: BitFlag;
        bit8: BitFlag;
        bit9: BitFlag;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            notification: boolean;
        }];
    };
    remoteProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
        pinAdded: BitFlag;
        pinChanged: BitFlag;
        pinCleared: BitFlag;
        rfidCodeAdded: BitFlag;
        rfidCodeCleared: BitFlag;
        unknown: BitFlag;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            notification: boolean;
        }];
    };
    requirePinForRemoteOperation: WritableAttribute<boolean, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            credentialOverTheAirAccess: boolean;
            pinCredential: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    rfidOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
        bit0: BitFlag;
        bit1: BitFlag;
        bit10: BitFlag;
        bit11: BitFlag;
        bit12: BitFlag;
        bit13: BitFlag;
        bit14: BitFlag;
        bit15: BitFlag;
        bit2: BitFlag;
        bit3: BitFlag;
        bit4: BitFlag;
        bit5: BitFlag;
        bit6: BitFlag;
        bit7: BitFlag;
        bit8: BitFlag;
        bit9: BitFlag;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            notification: boolean;
            rfidCredential: boolean;
        }];
    };
    rfidProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
        idAdded: BitFlag;
        idCleared: BitFlag;
        unknown: BitFlag;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            notification: boolean;
            rfidCredential: boolean;
        }];
    };
    sendPinOverTheAir: OptionalWritableAttribute<boolean, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            pinCredential: boolean;
            user: boolean;
        }];
    };
    soundVolume: OptionalWritableAttribute<DoorLock.SoundVolume, any>;
    supportedOperatingModes: FixedAttribute<TypeFromPartialBitSchema<{
        noRemoteLockUnlock: BitFlag;
        normal: BitFlag;
        passage: BitFlag;
        privacy: BitFlag;
        vacation: BitFlag;
    }>, any>;
    userCodeTemporaryDisableTime: WritableAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            pinCredential: boolean;
        }, {
            rfidCredential: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    wrongCodeEntryLimit: WritableAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            pinCredential: boolean;
        }, {
            rfidCredential: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
}, GlobalAttributes<{
    credentialOverTheAirAccess: BitFlag;
    doorPositionSensor: BitFlag;
    faceCredentials: BitFlag;
    fingerCredentials: BitFlag;
    holidaySchedules: BitFlag;
    logging: BitFlag;
    notification: BitFlag;
    pinCredential: BitFlag;
    rfidCredential: BitFlag;
    unbolting: BitFlag;
    user: BitFlag;
    weekDayAccessSchedules: BitFlag;
    yearDayAccessSchedules: BitFlag;
}>>

Type declaration

  • ReadonlyacceptedCommandList: Attribute<CommandId[], never>

    List of client generated commands which are supported by this cluster server instance.

  • ReadonlyactuatorEnabled: Attribute<boolean, any>

    Indicates if the lock is currently able to (Enabled) or not able to (Disabled) process remote Lock, Unlock, or Unlock with Timeout commands.

    MatterSpecification.v13.Cluster § 5.2.9.4

  • ReadonlyalarmMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
        doorForcedOpen: BitFlag;
        frontEscutcheonRemoved: BitFlag;
        lockFactoryReset: BitFlag;
        lockJammed: BitFlag;
        lockRadioPowerCycled: BitFlag;
        na: BitFlag;
        wrongCodeEntryLimit: BitFlag;
    }>, any>

    This attribute is only supported if the Alarms cluster is on the same endpoint. The alarm mask is used to turn on/off alarms for particular functions. Alarms for an alarm group are enabled if the associated alarm mask bit is set. Each bit represents a group of alarms. Entire alarm groups can be turned on or off by setting or clearing the associated bit in the alarm mask.

    This mask DOES NOT apply to the Events mechanism of this cluster.

    MatterSpecification.v13.Cluster § 5.2.9.40

  • ReadonlyattributeList: Attribute<AttributeId[], never>

    List of the attribute IDs of the attributes supported by the cluster instance.

  • ReadonlyautoRelockTime: OptionalWritableAttribute<number, any>

    Indicates the number of seconds to wait after unlocking a lock before it automatically locks again. 0=disabled. If set, unlock operations from any source will be timed. For one time unlock with timeout use the specific command.

    MatterSpecification.v13.Cluster § 5.2.9.25

  • ReadonlyclusterRevision: Attribute<number, never>

    Indicates the revision of the server cluster specification supported by the cluster instance.

  • ReadonlycredentialRulesSupport: FixedAttribute<TypeFromPartialBitSchema<{
        dual: BitFlag;
        single: BitFlag;
        tri: BitFlag;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            user: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlydefaultConfigurationRegister: OptionalAttribute<TypeFromPartialBitSchema<{
        autoRelockTime: BitFlag;
        keypadInterface: BitFlag;
        ledSettings: BitFlag;
        localProgramming: BitFlag;
        remoteInterface: BitFlag;
        soundVolume: BitFlag;
    }>, any>

    Indicates the default configurations as they are physically set on the device (example: hardware dip switch setting, etc…) and represents the default setting for some of the attributes within this cluster (for example: LED, Auto Lock, Sound Volume, and Operating Mode attributes).

    This is a read-only attribute and is intended to allow clients to determine what changes may need to be made without having to query all the included attributes. It may be beneficial for the clients to know what the device’s original settings were in the event that the device needs to be restored to factory default settings.

    If the Client device would like to query and modify the door lock server’s operating settings, it SHOULD send read and write attribute requests to the specific attributes.

    For example, the Sound Volume attribute default value is Silent Mode. However, it is possible that the current Sound Volume is High Volume. Therefore, if the client wants to query/modify the current Sound Volume setting on the server, the client SHOULD read/write to the Sound Volume attribute.

    MatterSpecification.v13.Cluster § 5.2.9.29

  • ReadonlydoorClosedEvents: OptionalWritableAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            doorPositionSensor: boolean;
        }];
    }
  • ReadonlydoorOpenEvents: OptionalWritableAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            doorPositionSensor: boolean;
        }];
    }
  • ReadonlydoorState: Attribute<null | DoorLock.DoorState, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            doorPositionSensor: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlyenableInsideStatusLed: OptionalWritableAttribute<boolean, any>

    This attribute shall enable/disable an inside LED that allows the user to see at a glance if the door is locked.

    MatterSpecification.v13.Cluster § 5.2.9.32

  • ReadonlyenableLocalProgramming: OptionalWritableAttribute<boolean, any>

    This attribute shall enable/disable local programming on the door lock of certain features (see LocalProgrammingFeatures attribute). If this value is set to TRUE then local programming is enabled on the door lock for all features. If it is set to FALSE then local programming is disabled on the door lock for those features whose bit is set to 0 in the LocalProgrammingFeatures attribute. Local programming shall be enabled by default.

    MatterSpecification.v13.Cluster § 5.2.9.30

  • ReadonlyenableLogging: WritableAttribute<boolean, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            logging: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlyenableOneTouchLocking: OptionalWritableAttribute<boolean, any>

    This attribute shall enable/disable the ability to lock the door lock with a single touch on the door lock.

    MatterSpecification.v13.Cluster § 5.2.9.31

  • ReadonlyenablePrivacyModeButton: OptionalWritableAttribute<boolean, any>

    This attribute shall enable/disable a button inside the door that is used to put the lock into privacy mode. When the lock is in privacy mode it cannot be manipulated from the outside.

    MatterSpecification.v13.Cluster § 5.2.9.33

  • ReadonlyexpiringUserTimeout: OptionalWritableAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            user: boolean;
        }];
    }
  • ReadonlyfeatureMap: Attribute<TypeFromPartialBitSchema<{
        credentialOverTheAirAccess: BitFlag;
        doorPositionSensor: BitFlag;
        faceCredentials: BitFlag;
        fingerCredentials: BitFlag;
        holidaySchedules: BitFlag;
        logging: BitFlag;
        notification: BitFlag;
        pinCredential: BitFlag;
        rfidCredential: BitFlag;
        unbolting: BitFlag;
        user: BitFlag;
        weekDayAccessSchedules: BitFlag;
        yearDayAccessSchedules: BitFlag;
    }>, never>

    Indicates whether the server supports zero or more optional cluster features.

  • ReadonlygeneratedCommandList: Attribute<CommandId[], never>

    List of server generated commands (server to client commands).

  • ReadonlykeypadOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
        bit0: BitFlag;
        bit1: BitFlag;
        bit10: BitFlag;
        bit11: BitFlag;
        bit12: BitFlag;
        bit13: BitFlag;
        bit14: BitFlag;
        bit15: BitFlag;
        bit2: BitFlag;
        bit3: BitFlag;
        bit4: BitFlag;
        bit5: BitFlag;
        bit6: BitFlag;
        bit7: BitFlag;
        bit8: BitFlag;
        bit9: BitFlag;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            notification: boolean;
            pinCredential: boolean;
        }];
    }
  • ReadonlykeypadProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
        pinAdded: BitFlag;
        pinChanged: BitFlag;
        pinCleared: BitFlag;
        pinCodeChanged: BitFlag;
        unknown: BitFlag;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            notification: boolean;
            pinCredential: boolean;
        }];
    }
  • Readonlylanguage: OptionalWritableAttribute<string, any>

    Indicates the language for the on-screen or audible user interface using a 2- byte language code from ISO-639-1.

    MatterSpecification.v13.Cluster § 5.2.9.23

  • ReadonlyledSettings: OptionalWritableAttribute<DoorLock.LedSetting, any>

    Indicates the settings for the LED support, as defined by LEDSettingEnum.

    MatterSpecification.v13.Cluster § 5.2.9.24

  • ReadonlylocalProgrammingFeatures: OptionalWritableAttribute<TypeFromPartialBitSchema<{
        addUsersCredentialsSchedules: BitFlag;
        adjustSettings: BitFlag;
        clearUsersCredentialsSchedules: BitFlag;
        modifyUsersCredentialsSchedules: BitFlag;
    }>, any>

    Indicates the local programming features that will be disabled when EnableLocalProgramming attribute is set to False. If a door lock doesn’t support disabling one aspect of local programming it shall return CONSTRAINT_ERROR during a write operation of this attribute. If the EnableLocalProgramming attribute is set to True then all local programming features shall be enabled regardless of the bits set to 0 in this attribute.

    The features that can be disabled from local programming are defined in LocalProgrammingFeaturesBitmap.

    MatterSpecification.v13.Cluster § 5.2.9.34

  • ReadonlylockState: Attribute<null | DoorLock.LockState, any>

    This attribute may be NULL if the lock hardware does not currently know the status of the locking mechanism. For example, a lock may not know the LockState status after a power cycle until the first lock actuation is completed.

    The Not Fully Locked value is used by a lock to indicate that the state of the lock is somewhere between Locked and Unlocked so it is only partially secured. For example, a deadbolt could be partially extended and not in a dead latched state.

    MatterSpecification.v13.Cluster § 5.2.9.2

  • ReadonlylockType: Attribute<DoorLock.LockType, any>

    Indicates the type of door lock as defined in LockTypeEnum.

    MatterSpecification.v13.Cluster § 5.2.9.3

  • ReadonlymanualOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
        bit0: BitFlag;
        bit1: BitFlag;
        bit10: BitFlag;
        bit11: BitFlag;
        bit12: BitFlag;
        bit13: BitFlag;
        bit14: BitFlag;
        bit15: BitFlag;
        bit2: BitFlag;
        bit3: BitFlag;
        bit4: BitFlag;
        bit5: BitFlag;
        bit6: BitFlag;
        bit7: BitFlag;
        bit8: BitFlag;
        bit9: BitFlag;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            notification: boolean;
        }];
    }
  • ReadonlymaxPinCodeLength: FixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            pinCredential: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlymaxRfidCodeLength: FixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            rfidCredential: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlyminPinCodeLength: FixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            pinCredential: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlyminRfidCodeLength: FixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            rfidCredential: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlynumberOfCredentialsSupportedPerUser: FixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            user: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlynumberOfHolidaySchedulesSupported: FixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            holidaySchedules: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlynumberOfLogRecordsSupported: FixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            logging: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlynumberOfPinUsersSupported: FixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            pinCredential: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlynumberOfRfidUsersSupported: FixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            rfidCredential: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlynumberOfTotalUsersSupported: FixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            user: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlynumberOfWeekDaySchedulesSupportedPerUser: FixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            weekDayAccessSchedules: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlynumberOfYearDaySchedulesSupportedPerUser: FixedAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            yearDayAccessSchedules: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlyopenPeriod: OptionalWritableAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            doorPositionSensor: boolean;
        }];
    }
  • ReadonlyoperatingMode: WritableAttribute<DoorLock.OperatingMode, any>

    Indicates the current operating mode of the lock as defined in OperatingModeEnum.

    MatterSpecification.v13.Cluster § 5.2.9.27

  • ReadonlyremoteOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
        bit0: BitFlag;
        bit1: BitFlag;
        bit10: BitFlag;
        bit11: BitFlag;
        bit12: BitFlag;
        bit13: BitFlag;
        bit14: BitFlag;
        bit15: BitFlag;
        bit2: BitFlag;
        bit3: BitFlag;
        bit4: BitFlag;
        bit5: BitFlag;
        bit6: BitFlag;
        bit7: BitFlag;
        bit8: BitFlag;
        bit9: BitFlag;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            notification: boolean;
        }];
    }
  • ReadonlyremoteProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
        pinAdded: BitFlag;
        pinChanged: BitFlag;
        pinCleared: BitFlag;
        rfidCodeAdded: BitFlag;
        rfidCodeCleared: BitFlag;
        unknown: BitFlag;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            notification: boolean;
        }];
    }
  • ReadonlyrequirePinForRemoteOperation: WritableAttribute<boolean, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            credentialOverTheAirAccess: boolean;
            pinCredential: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlyrfidOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
        bit0: BitFlag;
        bit1: BitFlag;
        bit10: BitFlag;
        bit11: BitFlag;
        bit12: BitFlag;
        bit13: BitFlag;
        bit14: BitFlag;
        bit15: BitFlag;
        bit2: BitFlag;
        bit3: BitFlag;
        bit4: BitFlag;
        bit5: BitFlag;
        bit6: BitFlag;
        bit7: BitFlag;
        bit8: BitFlag;
        bit9: BitFlag;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            notification: boolean;
            rfidCredential: boolean;
        }];
    }
  • ReadonlyrfidProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
        idAdded: BitFlag;
        idCleared: BitFlag;
        unknown: BitFlag;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            notification: boolean;
            rfidCredential: boolean;
        }];
    }
  • ReadonlysendPinOverTheAir: OptionalWritableAttribute<boolean, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            pinCredential: boolean;
            user: boolean;
        }];
    }
  • ReadonlysoundVolume: OptionalWritableAttribute<DoorLock.SoundVolume, any>

    Indicates the sound volume on a door lock as defined by SoundVolumeEnum.

    MatterSpecification.v13.Cluster § 5.2.9.26

  • ReadonlysupportedOperatingModes: FixedAttribute<TypeFromPartialBitSchema<{
        noRemoteLockUnlock: BitFlag;
        normal: BitFlag;
        passage: BitFlag;
        privacy: BitFlag;
        vacation: BitFlag;
    }>, any>

    This attribute shall contain a bitmap with all operating bits of the OperatingMode attribute supported by the lock. All operating modes NOT supported by a lock shall be set to one. The value of the OperatingMode enumeration defines the related bit to be set.

    MatterSpecification.v13.Cluster § 5.2.9.28

  • ReadonlyuserCodeTemporaryDisableTime: WritableAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            pinCredential: boolean;
        }, {
            rfidCredential: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlywrongCodeEntryLimit: WritableAttribute<number, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            pinCredential: boolean;
        }, {
            rfidCredential: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
base: undefined
commands: {
    clearAllPinCodes: Command<void, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            pinCredential: boolean;
            user: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    clearAllRfidCodes: Command<void, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            rfidCredential: boolean;
            user: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    clearCredential: Command<TypeFromFields<{
        credential: FieldType<null | TypeFromFields<{
            credentialIndex: FieldType<number>;
            credentialType: FieldType<DoorLock.CredentialType>;
        }>>;
    }>, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            user: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    clearHolidaySchedule: Command<TypeFromFields<{
        holidayIndex: FieldType<number>;
    }>, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            holidaySchedules: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    clearPinCode: Command<TypeFromFields<{
        pinSlotIndex: FieldType<number>;
    }>, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            pinCredential: boolean;
            user: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    clearRfidCode: Command<TypeFromFields<{
        rfidSlotIndex: FieldType<number>;
    }>, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            rfidCredential: boolean;
            user: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    clearUser: Command<TypeFromFields<{
        userIndex: FieldType<number>;
    }>, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            user: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    clearWeekDaySchedule: Command<TypeFromFields<{
        userIndexUserId: FieldType<number>;
        weekDayIndex: FieldType<number>;
    }>, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            weekDayAccessSchedules: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    clearYearDaySchedule: Command<TypeFromFields<{
        userIndexUserId: FieldType<number>;
        yearDayIndex: FieldType<number>;
    }>, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            yearDayAccessSchedules: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    getCredentialStatus: Command<TypeFromFields<{
        credential: FieldType<TypeFromFields<{
            credentialIndex: FieldType<number>;
            credentialType: FieldType<DoorLock.CredentialType>;
        }>>;
    }>, TypeFromFields<{
        creatorFabricIndex: FieldType<null | FabricIndex>;
        credentialExists: FieldType<boolean>;
        lastModifiedFabricIndex: FieldType<null | FabricIndex>;
        nextCredentialIndex: OptionalFieldType<null | number>;
        userIndex: FieldType<null | number>;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            user: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    getHolidaySchedule: Command<TypeFromFields<{
        holidayIndex: FieldType<number>;
    }>, TypeFromFields<{
        holidayIndex: FieldType<number>;
        localEndTime: OptionalFieldType<null | number>;
        localStartTime: OptionalFieldType<null | number>;
        operatingMode: OptionalFieldType<null | DoorLock.OperatingMode>;
        status: FieldType<Status>;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            holidaySchedules: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    getLogRecord: Command<TypeFromFields<{
        logIndex: FieldType<number>;
    }>, TypeFromFields<{
        eventId: FieldType<number>;
        eventType: FieldType<DoorLock.EventType>;
        logEntryId: FieldType<number>;
        pin: FieldType<Uint8Array>;
        source: FieldType<DoorLock.EventSource>;
        timestamp: FieldType<number>;
        userId: FieldType<number>;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            logging: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    getPinCode: Command<TypeFromFields<{
        userId: FieldType<number>;
    }>, TypeFromFields<{
        pinCode: FieldType<null | Uint8Array>;
        userId: FieldType<number>;
        userStatus: FieldType<null | DoorLock.UserStatus>;
        userType: FieldType<null | DoorLock.UserType>;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            pinCredential: boolean;
            user: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    getRfidCode: Command<TypeFromFields<{
        userId: FieldType<number>;
    }>, TypeFromFields<{
        rfidCode: FieldType<null | Uint8Array>;
        userId: FieldType<number>;
        userStatus: FieldType<null | DoorLock.UserStatus>;
        userType: FieldType<null | DoorLock.UserType>;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            rfidCredential: boolean;
            user: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    getUser: Command<TypeFromFields<{
        userIndex: FieldType<number>;
    }>, TypeFromFields<{
        creatorFabricIndex: FieldType<null | FabricIndex>;
        credentialRule: FieldType<null | DoorLock.CredentialRule>;
        credentials: FieldType<null | TypeFromFields<{
            credentialIndex: FieldType<(...)>;
            credentialType: FieldType<(...)>;
        }>[]>;
        lastModifiedFabricIndex: FieldType<null | FabricIndex>;
        nextUserIndex: FieldType<null | number>;
        userIndex: FieldType<number>;
        userName: FieldType<null | string>;
        userStatus: FieldType<null | DoorLock.UserStatus>;
        userType: FieldType<null | DoorLock.UserType>;
        userUniqueId: FieldType<null | number>;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            user: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    getUserStatus: OptionalCommand<TypeFromFields<{
        userId: FieldType<number>;
    }>, TypeFromFields<{
        userId: FieldType<number>;
        userStatus: FieldType<DoorLock.UserStatus>;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            fingerCredentials: boolean;
            pinCredential: boolean;
            rfidCredential: boolean;
            user: boolean;
        }];
    };
    getUserType: OptionalCommand<TypeFromFields<{
        userId: FieldType<number>;
    }>, TypeFromFields<{
        userId: FieldType<number>;
        userType: FieldType<DoorLock.UserType>;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            fingerCredentials: boolean;
            pinCredential: boolean;
            rfidCredential: boolean;
            user: boolean;
        }];
    };
    getWeekDaySchedule: Command<TypeFromFields<{
        userIndexUserId: FieldType<number>;
        weekDayIndex: FieldType<number>;
    }>, TypeFromFields<{
        daysMask: OptionalFieldType<TypeFromPartialBitSchema<{
            friday: BitFlag;
            monday: BitFlag;
            saturday: BitFlag;
            sunday: BitFlag;
            thursday: BitFlag;
            tuesday: BitFlag;
            wednesday: BitFlag;
        }>>;
        endHour: OptionalFieldType<number>;
        endMinute: OptionalFieldType<number>;
        startHour: OptionalFieldType<number>;
        startMinute: OptionalFieldType<number>;
        status: FieldType<Status>;
        userIndexUserId: FieldType<number>;
        weekDayIndex: FieldType<number>;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            weekDayAccessSchedules: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    getYearDaySchedule: Command<TypeFromFields<{
        userIndexUserId: FieldType<number>;
        yearDayIndex: FieldType<number>;
    }>, TypeFromFields<{
        localEndTime: OptionalFieldType<number>;
        localStartTime: OptionalFieldType<number>;
        status: FieldType<Status>;
        userIndexUserId: FieldType<number>;
        yearDayIndex: FieldType<number>;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            yearDayAccessSchedules: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    lockDoor: Command<TypeFromFields<{
        pinCode: OptionalFieldType<Uint8Array>;
    }>, void, any>;
    setCredential: Command<TypeFromFields<{
        credential: FieldType<TypeFromFields<{
            credentialIndex: FieldType<number>;
            credentialType: FieldType<DoorLock.CredentialType>;
        }>>;
        credentialData: FieldType<Uint8Array>;
        operationType: FieldType<DoorLock.DataOperationType>;
        userIndex: FieldType<null | number>;
        userStatus: FieldType<null | DoorLock.UserStatus>;
        userType: FieldType<null | DoorLock.UserType>;
    }>, TypeFromFields<{
        nextCredentialIndex: OptionalFieldType<null | number>;
        status: FieldType<Status>;
        userIndex: FieldType<null | number>;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            user: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    setHolidaySchedule: Command<TypeFromFields<{
        holidayIndex: FieldType<number>;
        localEndTime: FieldType<number>;
        localStartTime: FieldType<number>;
        operatingMode: FieldType<DoorLock.OperatingMode>;
    }>, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            holidaySchedules: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    setPinCode: Command<TypeFromFields<{
        pin: FieldType<Uint8Array>;
        userId: FieldType<number>;
        userStatus: FieldType<null | DoorLock.UserStatus>;
        userType: FieldType<null | DoorLock.UserType>;
    }>, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            pinCredential: boolean;
            user: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    setRfidCode: Command<TypeFromFields<{
        rfidCode: FieldType<Uint8Array>;
        userId: FieldType<number>;
        userStatus: FieldType<null | DoorLock.UserStatus>;
        userType: FieldType<null | DoorLock.UserType>;
    }>, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            rfidCredential: boolean;
            user: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    setUser: Command<TypeFromFields<{
        credentialRule: FieldType<null | DoorLock.CredentialRule>;
        operationType: FieldType<DoorLock.DataOperationType>;
        userIndex: FieldType<number>;
        userName: FieldType<null | string>;
        userStatus: FieldType<null | DoorLock.UserStatus>;
        userType: FieldType<null | DoorLock.UserType>;
        userUniqueId: FieldType<null | number>;
    }>, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            user: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    setUserStatus: OptionalCommand<TypeFromFields<{
        userId: FieldType<number>;
        userStatus: FieldType<DoorLock.UserStatus>;
    }>, void, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            fingerCredentials: boolean;
            pinCredential: boolean;
            rfidCredential: boolean;
            user: boolean;
        }];
    };
    setUserType: OptionalCommand<TypeFromFields<{
        userId: FieldType<number>;
        userType: FieldType<DoorLock.UserType>;
    }>, void, any> & {
        isConditional: true;
        mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
        optional: true;
        optionalIf: [] | [{
            fingerCredentials: boolean;
            pinCredential: boolean;
            rfidCredential: boolean;
            user: boolean;
        }];
    };
    setWeekDaySchedule: Command<TypeFromFields<{
        daysMask: FieldType<TypeFromPartialBitSchema<{
            friday: BitFlag;
            monday: BitFlag;
            saturday: BitFlag;
            sunday: BitFlag;
            thursday: BitFlag;
            tuesday: BitFlag;
            wednesday: BitFlag;
        }>>;
        endHour: FieldType<number>;
        endMinute: FieldType<number>;
        startHour: FieldType<number>;
        startMinute: FieldType<number>;
        userIndexUserId: FieldType<number>;
        weekDayIndex: FieldType<number>;
    }>, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            weekDayAccessSchedules: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    setYearDaySchedule: Command<TypeFromFields<{
        localEndTime: FieldType<number>;
        localStartTime: FieldType<number>;
        userIndexUserId: FieldType<number>;
        yearDayIndex: FieldType<number>;
    }>, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            yearDayAccessSchedules: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    unboltDoor: Command<TypeFromFields<{
        pinCode: OptionalFieldType<Uint8Array>;
    }>, void, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            unbolting: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    unlockDoor: Command<TypeFromFields<{
        pinCode: OptionalFieldType<Uint8Array>;
    }>, void, any>;
    unlockWithTimeout: OptionalCommand<TypeFromFields<{
        pinCode: OptionalFieldType<Uint8Array>;
        timeout: FieldType<number>;
    }>, void, any>;
}

Type declaration

events: {
    doorLockAlarm: Event<TypeFromFields<{
        alarmCode: FieldType<DoorLock.AlarmCode>;
    }>, any>;
    doorStateChange: Event<TypeFromFields<{
        doorState: FieldType<DoorLock.DoorState>;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            doorPositionSensor: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
    lockOperation: Event<TypeFromFields<{
        credentials: OptionalFieldType<null | TypeFromFields<{
            credentialIndex: FieldType<number>;
            credentialType: FieldType<DoorLock.CredentialType>;
        }>[]>;
        fabricIndex: FieldType<null | FabricIndex>;
        lockOperationType: FieldType<DoorLock.LockOperationType>;
        operationSource: FieldType<DoorLock.OperationSource>;
        sourceNode: FieldType<null | NodeId>;
        userIndex: FieldType<null | number>;
    }>, any>;
    lockOperationError: Event<TypeFromFields<{
        credentials: OptionalFieldType<null | TypeFromFields<{
            credentialIndex: FieldType<number>;
            credentialType: FieldType<DoorLock.CredentialType>;
        }>[]>;
        fabricIndex: FieldType<null | FabricIndex>;
        lockOperationType: FieldType<DoorLock.LockOperationType>;
        operationError: FieldType<DoorLock.OperationError>;
        operationSource: FieldType<DoorLock.OperationSource>;
        sourceNode: FieldType<null | NodeId>;
        userIndex: FieldType<null | number>;
    }>, any>;
    lockUserChange: Event<TypeFromFields<{
        dataIndex: FieldType<null | number>;
        dataOperationType: FieldType<DoorLock.DataOperationType>;
        fabricIndex: FieldType<null | FabricIndex>;
        lockDataType: FieldType<DoorLock.LockDataType>;
        operationSource: FieldType<DoorLock.OperationSource>;
        sourceNode: FieldType<null | NodeId>;
        userIndex: FieldType<null | number>;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            user: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    };
}

Type declaration

  • ReadonlydoorLockAlarm: Event<TypeFromFields<{
        alarmCode: FieldType<DoorLock.AlarmCode>;
    }>, any>

    The door lock server provides several alarms which can be sent when there is a critical state on the door lock. The alarms available for the door lock server are listed in AlarmCodeEnum.

    MatterSpecification.v13.Cluster § 5.2.11.1

  • ReadonlydoorStateChange: Event<TypeFromFields<{
        doorState: FieldType<DoorLock.DoorState>;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            doorPositionSensor: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
  • ReadonlylockOperation: Event<TypeFromFields<{
        credentials: OptionalFieldType<null | TypeFromFields<{
            credentialIndex: FieldType<number>;
            credentialType: FieldType<DoorLock.CredentialType>;
        }>[]>;
        fabricIndex: FieldType<null | FabricIndex>;
        lockOperationType: FieldType<DoorLock.LockOperationType>;
        operationSource: FieldType<DoorLock.OperationSource>;
        sourceNode: FieldType<null | NodeId>;
        userIndex: FieldType<null | number>;
    }>, any>

    The door lock server sends out a LockOperation event when the event is triggered by the various lock operation sources.

    • If the door lock server supports the Unbolt Door command, it shall generate a LockOperation event with LockOperationType set to Unlock after an Unbolt Door command succeeds.

    • If the door lock server supports the Unbolting feature and an Unlock Door command is performed, it shall generate a LockOperation event with LockOperationType set to Unlatch when the unlatched state is reached and a LockOperation event with LockOperationType set to Unlock when the lock successfully completes the unlock → hold latch → release latch and return to unlock state operation.

    • If the command fails during holding or releasing the latch but after passing the unlocked state, the door lock server shall generate a LockOperationError event with LockOperationType set to Unlatch and a LockOperation event with LockOperationType set to Unlock.

    ◦ If it fails before reaching the unlocked state, the door lock server shall generate only a
      LockOperationError event with LockOperationType set to Unlock.
    

    • Upon manual actuation, a door lock server that supports the Unbolting feature:

    ◦ shall generate a LockOperation event of LockOperationType Unlatch when it is actuated from the
      outside.
    
    ◦ may generate a LockOperation event of LockOperationType Unlatch when it is actuated from the
      inside.
    

    MatterSpecification.v13.Cluster § 5.2.11.3

  • ReadonlylockOperationError: Event<TypeFromFields<{
        credentials: OptionalFieldType<null | TypeFromFields<{
            credentialIndex: FieldType<number>;
            credentialType: FieldType<DoorLock.CredentialType>;
        }>[]>;
        fabricIndex: FieldType<null | FabricIndex>;
        lockOperationType: FieldType<DoorLock.LockOperationType>;
        operationError: FieldType<DoorLock.OperationError>;
        operationSource: FieldType<DoorLock.OperationSource>;
        sourceNode: FieldType<null | NodeId>;
        userIndex: FieldType<null | number>;
    }>, any>

    The door lock server sends out a LockOperationError event when a lock operation fails for various reasons.

    MatterSpecification.v13.Cluster § 5.2.11.4

  • ReadonlylockUserChange: Event<TypeFromFields<{
        dataIndex: FieldType<null | number>;
        dataOperationType: FieldType<DoorLock.DataOperationType>;
        fabricIndex: FieldType<null | FabricIndex>;
        lockDataType: FieldType<DoorLock.LockDataType>;
        operationSource: FieldType<DoorLock.OperationSource>;
        sourceNode: FieldType<null | NodeId>;
        userIndex: FieldType<null | number>;
    }>, any> & {
        isConditional: true;
        mandatoryIf: [] | [{
            user: boolean;
        }];
        optional: true;
        optionalIf: [] | ConditionalFeatureList<BitSchema>;
    }
extensions: undefined
features: {
    credentialOverTheAirAccess: BitFlag;
    doorPositionSensor: BitFlag;
    faceCredentials: BitFlag;
    fingerCredentials: BitFlag;
    holidaySchedules: BitFlag;
    logging: BitFlag;
    notification: BitFlag;
    pinCredential: BitFlag;
    rfidCredential: BitFlag;
    unbolting: BitFlag;
    user: BitFlag;
    weekDayAccessSchedules: BitFlag;
    yearDayAccessSchedules: BitFlag;
}

Type declaration

  • ReadonlycredentialOverTheAirAccess: BitFlag

    CredentialOverTheAirAccess

    If this feature is supported then the lock supports the ability to verify a credential provided in a lock/unlock command. Currently the cluster only supports providing the PIN credential to the lock/unlock commands. If this feature is supported then the PIN Credential feature shall also be supported.

    MatterSpecification.v13.Cluster § 5.2.4.8

  • ReadonlydoorPositionSensor: BitFlag

    DoorPositionSensor

    If this feature is supported this indicates that the lock has the ability to determine the position of the door which is separate from the state of the lock.

    MatterSpecification.v13.Cluster § 5.2.4.6

  • ReadonlyfaceCredentials: BitFlag

    FaceCredentials

    Currently the cluster only defines the metadata format for notifications when a face recognition, iris, or retina credential is used to access the lock and doesn’t describe how to create face recognition, iris, or retina credentials. If the Users feature is also supported then the User that a face recognition, iris, or retina credential is associated with can also have its UserType, UserStatus and Schedule modified.

    A lock may support multiple credential types so if the User feature is supported the UserType, UserStatus and Schedules are all associated with a User and not directly with a credential.

    MatterSpecification.v13.Cluster § 5.2.4.7

  • ReadonlyfingerCredentials: BitFlag

    FingerCredentials

    Currently the cluster only defines the metadata format for notifications when a fingerprint/ finger vein credential is used to access the lock and doesn’t describe how to create fingerprint/finger vein credentials. If the Users feature is also supported then the User that a fingerprint/finger vein is associated with can also have its UserType, UserStatus and Schedule modified.

    A lock may support multiple credential types so if the User feature is supported the UserType, UserStatus and Schedules are all associated with a User index and not directly with a Finger index. A User Index may have several credentials associated with it.

    MatterSpecification.v13.Cluster § 5.2.4.3

  • ReadonlyholidaySchedules: BitFlag

    HolidaySchedules

    This feature is used to setup Holiday Schedule in the lock device. A Holiday Schedule sets a start and stop end date/time for the lock to use the specified operating mode set by the Holiday Schedule.

    MatterSpecification.v13.Cluster § 5.2.4.12

  • Readonlylogging: BitFlag

    Logging

    If Events are not supported the logging feature shall replace the Event reporting structure. If Events are supported the logging feature shall NOT be supported.

    MatterSpecification.v13.Cluster § 5.2.4.4

  • Readonlynotification: BitFlag

    Notification

    This is a feature used before support of events. This feature supports notification commands and masks used to filter these notifications.

    MatterSpecification.v13.Cluster § 5.2.4.10

  • ReadonlypinCredential: BitFlag

    PinCredential

    If the User Feature is also supported then any PIN Code stored in the lock shall be associated with a User.

    A lock may support multiple credential types so if the User feature is supported the UserType, UserStatus and Schedules are all associated with a User index and not directly with a PIN index. A User index may have several credentials associated with it.

    MatterSpecification.v13.Cluster § 5.2.4.1

  • ReadonlyrfidCredential: BitFlag

    RfidCredential

    If the User Feature is also supported then any RFID credential stored in the lock shall be associated with a User.

    A lock may support multiple credential types so if the User feature is supported the UserType, UserStatus and Schedules are all associated with a User index and not directly with a RFID index. A User

    Index may have several credentials associated with it.

    MatterSpecification.v13.Cluster § 5.2.4.2

  • Readonlyunbolting: BitFlag

    Unbolting

    Locks that support this feature differentiate between unbolting and unlocking. The Unbolt Door command retracts the bolt without pulling the latch. The Unlock Door command fully unlocks the door by retracting the bolt and briefly pulling the latch. While the latch is pulled, the lock state changes to Unlatched. Locks without unbolting support don’t differentiate between unbolting and unlocking and perform the same operation for both commands.

    MatterSpecification.v13.Cluster § 5.2.4.13

  • Readonlyuser: BitFlag

    User

    If the User Feature is supported then a lock employs a User database. A User within the User database is used to associate credentials and schedules to single user record within the lock. This also means the UserType and UserStatus fields are associated with a User and not a credential.

    MatterSpecification.v13.Cluster § 5.2.4.9

  • ReadonlyweekDayAccessSchedules: BitFlag

    WeekDayAccessSchedules

    If the User feature is supported then Week Day Schedules are applied to a User and not a credential.

    Week Day Schedules are used to restrict access to a specified time window on certain days of the week. The schedule is repeated each week. When a schedule is cleared this clears the access restrictions and grants unrestricted access to the user. The lock may automatically adjust the UserType when a schedule is created or cleared.

    MatterSpecification.v13.Cluster § 5.2.4.5

  • ReadonlyyearDayAccessSchedules: BitFlag

    YearDayAccessSchedules

    If the User feature is supported then Year Day Schedules are applied to a User and not a credential.

    Year Day Schedules are used to restrict access to a specified date and time window. When a schedule is cleared this clears the access restrictions and grants unrestricted access to the user. The lock may automatically adjust the UserType when a schedule is created or cleared.

    MatterSpecification.v13.Cluster § 5.2.4.11

id: Branded<Branded<257, "ClusterId">, "ClusterId">
name
revision
supportedFeatures: {}
unknown

Methods

  • Modify elements using ElementModifier.alter.

    Type Parameters

    • const AlterationsT extends Alterations<Of<{
          attributes: {
              acceptedCommandList: Attribute<CommandId[], never>;
              actuatorEnabled: Attribute<boolean, any>;
              alarmMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                  doorForcedOpen: BitFlag;
                  frontEscutcheonRemoved: BitFlag;
                  lockFactoryReset: BitFlag;
                  lockJammed: BitFlag;
                  lockRadioPowerCycled: BitFlag;
                  na: BitFlag;
                  wrongCodeEntryLimit: BitFlag;
              }>, any>;
              attributeList: Attribute<AttributeId[], never>;
              autoRelockTime: OptionalWritableAttribute<number, any>;
              clusterRevision: Attribute<number, never>;
              credentialRulesSupport: FixedAttribute<TypeFromPartialBitSchema<{
                  dual: BitFlag;
                  single: BitFlag;
                  tri: BitFlag;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      user: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              defaultConfigurationRegister: OptionalAttribute<TypeFromPartialBitSchema<{
                  autoRelockTime: BitFlag;
                  keypadInterface: BitFlag;
                  ledSettings: BitFlag;
                  localProgramming: BitFlag;
                  remoteInterface: BitFlag;
                  soundVolume: BitFlag;
              }>, any>;
              doorClosedEvents: OptionalWritableAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      doorPositionSensor: boolean;
                  }];
              };
              doorOpenEvents: OptionalWritableAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      doorPositionSensor: boolean;
                  }];
              };
              doorState: Attribute<null | DoorLock.DoorState, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      doorPositionSensor: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              enableInsideStatusLed: OptionalWritableAttribute<boolean, any>;
              enableLocalProgramming: OptionalWritableAttribute<boolean, any>;
              enableLogging: WritableAttribute<boolean, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      logging: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              enableOneTouchLocking: OptionalWritableAttribute<boolean, any>;
              enablePrivacyModeButton: OptionalWritableAttribute<boolean, any>;
              expiringUserTimeout: OptionalWritableAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      user: boolean;
                  }];
              };
              featureMap: Attribute<TypeFromPartialBitSchema<{
                  credentialOverTheAirAccess: BitFlag;
                  doorPositionSensor: BitFlag;
                  faceCredentials: BitFlag;
                  fingerCredentials: BitFlag;
                  holidaySchedules: BitFlag;
                  logging: BitFlag;
                  notification: BitFlag;
                  pinCredential: BitFlag;
                  rfidCredential: BitFlag;
                  unbolting: BitFlag;
                  user: BitFlag;
                  weekDayAccessSchedules: BitFlag;
                  yearDayAccessSchedules: BitFlag;
              }>, never>;
              generatedCommandList: Attribute<CommandId[], never>;
              keypadOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                  bit0: BitFlag;
                  bit1: BitFlag;
                  bit10: BitFlag;
                  bit11: BitFlag;
                  bit12: BitFlag;
                  bit13: BitFlag;
                  bit14: BitFlag;
                  bit15: BitFlag;
                  bit2: BitFlag;
                  bit3: BitFlag;
                  bit4: BitFlag;
                  bit5: BitFlag;
                  bit6: BitFlag;
                  bit7: BitFlag;
                  bit8: BitFlag;
                  bit9: BitFlag;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      notification: boolean;
                      pinCredential: boolean;
                  }];
              };
              keypadProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                  pinAdded: BitFlag;
                  pinChanged: BitFlag;
                  pinCleared: BitFlag;
                  pinCodeChanged: BitFlag;
                  unknown: BitFlag;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      notification: boolean;
                      pinCredential: boolean;
                  }];
              };
              language: OptionalWritableAttribute<string, any>;
              ledSettings: OptionalWritableAttribute<DoorLock.LedSetting, any>;
              localProgrammingFeatures: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                  addUsersCredentialsSchedules: BitFlag;
                  adjustSettings: BitFlag;
                  clearUsersCredentialsSchedules: BitFlag;
                  modifyUsersCredentialsSchedules: BitFlag;
              }>, any>;
              lockState: Attribute<null | DoorLock.LockState, any>;
              lockType: Attribute<DoorLock.LockType, any>;
              manualOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                  bit0: BitFlag;
                  bit1: BitFlag;
                  bit10: BitFlag;
                  bit11: BitFlag;
                  bit12: BitFlag;
                  bit13: BitFlag;
                  bit14: BitFlag;
                  bit15: BitFlag;
                  bit2: BitFlag;
                  bit3: BitFlag;
                  bit4: BitFlag;
                  bit5: BitFlag;
                  bit6: BitFlag;
                  bit7: BitFlag;
                  bit8: BitFlag;
                  bit9: BitFlag;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      notification: boolean;
                  }];
              };
              maxPinCodeLength: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      pinCredential: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              maxRfidCodeLength: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      rfidCredential: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              minPinCodeLength: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      pinCredential: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              minRfidCodeLength: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      rfidCredential: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              numberOfCredentialsSupportedPerUser: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      user: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              numberOfHolidaySchedulesSupported: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      holidaySchedules: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              numberOfLogRecordsSupported: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      logging: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              numberOfPinUsersSupported: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      pinCredential: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              numberOfRfidUsersSupported: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      rfidCredential: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              numberOfTotalUsersSupported: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      user: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              numberOfWeekDaySchedulesSupportedPerUser: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      weekDayAccessSchedules: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              numberOfYearDaySchedulesSupportedPerUser: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      yearDayAccessSchedules: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              openPeriod: OptionalWritableAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      doorPositionSensor: boolean;
                  }];
              };
              operatingMode: WritableAttribute<DoorLock.OperatingMode, any>;
              remoteOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                  bit0: BitFlag;
                  bit1: BitFlag;
                  bit10: BitFlag;
                  bit11: BitFlag;
                  bit12: BitFlag;
                  bit13: BitFlag;
                  bit14: BitFlag;
                  bit15: BitFlag;
                  bit2: BitFlag;
                  bit3: BitFlag;
                  bit4: BitFlag;
                  bit5: BitFlag;
                  bit6: BitFlag;
                  bit7: BitFlag;
                  bit8: BitFlag;
                  bit9: BitFlag;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      notification: boolean;
                  }];
              };
              remoteProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                  pinAdded: BitFlag;
                  pinChanged: BitFlag;
                  pinCleared: BitFlag;
                  rfidCodeAdded: BitFlag;
                  rfidCodeCleared: BitFlag;
                  unknown: BitFlag;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      notification: boolean;
                  }];
              };
              requirePinForRemoteOperation: WritableAttribute<boolean, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      credentialOverTheAirAccess: boolean;
                      pinCredential: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              rfidOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                  bit0: BitFlag;
                  bit1: BitFlag;
                  bit10: BitFlag;
                  bit11: BitFlag;
                  bit12: BitFlag;
                  bit13: BitFlag;
                  bit14: BitFlag;
                  bit15: BitFlag;
                  bit2: BitFlag;
                  bit3: BitFlag;
                  bit4: BitFlag;
                  bit5: BitFlag;
                  bit6: BitFlag;
                  bit7: BitFlag;
                  bit8: BitFlag;
                  bit9: BitFlag;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      notification: boolean;
                      rfidCredential: boolean;
                  }];
              };
              rfidProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                  idAdded: BitFlag;
                  idCleared: BitFlag;
                  unknown: BitFlag;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      notification: boolean;
                      rfidCredential: boolean;
                  }];
              };
              sendPinOverTheAir: OptionalWritableAttribute<boolean, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      pinCredential: boolean;
                      user: boolean;
                  }];
              };
              soundVolume: OptionalWritableAttribute<DoorLock.SoundVolume, any>;
              supportedOperatingModes: FixedAttribute<TypeFromPartialBitSchema<{
                  noRemoteLockUnlock: BitFlag;
                  normal: BitFlag;
                  passage: BitFlag;
                  privacy: BitFlag;
                  vacation: BitFlag;
              }>, any>;
              userCodeTemporaryDisableTime: WritableAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      pinCredential: boolean;
                  }, {
                      rfidCredential: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              wrongCodeEntryLimit: WritableAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      pinCredential: boolean;
                  }, {
                      rfidCredential: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
          };
          commands: {
              clearAllPinCodes: Command<void, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      pinCredential: boolean;
                      user: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              clearAllRfidCodes: Command<void, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      rfidCredential: boolean;
                      user: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              clearCredential: Command<TypeFromFields<{
                  credential: FieldType<null | TypeFromFields<(...)>>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      user: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              clearHolidaySchedule: Command<TypeFromFields<{
                  holidayIndex: FieldType<number>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      holidaySchedules: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              clearPinCode: Command<TypeFromFields<{
                  pinSlotIndex: FieldType<number>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      pinCredential: boolean;
                      user: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              clearRfidCode: Command<TypeFromFields<{
                  rfidSlotIndex: FieldType<number>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      rfidCredential: boolean;
                      user: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              clearUser: Command<TypeFromFields<{
                  userIndex: FieldType<number>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      user: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              clearWeekDaySchedule: Command<TypeFromFields<{
                  userIndexUserId: FieldType<number>;
                  weekDayIndex: FieldType<number>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      weekDayAccessSchedules: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              clearYearDaySchedule: Command<TypeFromFields<{
                  userIndexUserId: FieldType<number>;
                  yearDayIndex: FieldType<number>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      yearDayAccessSchedules: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              getCredentialStatus: Command<TypeFromFields<{
                  credential: FieldType<TypeFromFields<{
                      credentialIndex: ...;
                      credentialType: ...;
                  }>>;
              }>, TypeFromFields<{
                  creatorFabricIndex: FieldType<null | FabricIndex>;
                  credentialExists: FieldType<boolean>;
                  lastModifiedFabricIndex: FieldType<null | FabricIndex>;
                  nextCredentialIndex: OptionalFieldType<null | number>;
                  userIndex: FieldType<null | number>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      user: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              getHolidaySchedule: Command<TypeFromFields<{
                  holidayIndex: FieldType<number>;
              }>, TypeFromFields<{
                  holidayIndex: FieldType<number>;
                  localEndTime: OptionalFieldType<null | number>;
                  localStartTime: OptionalFieldType<null | number>;
                  operatingMode: OptionalFieldType<null | DoorLock.OperatingMode>;
                  status: FieldType<Status>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      holidaySchedules: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              getLogRecord: Command<TypeFromFields<{
                  logIndex: FieldType<number>;
              }>, TypeFromFields<{
                  eventId: FieldType<number>;
                  eventType: FieldType<DoorLock.EventType>;
                  logEntryId: FieldType<number>;
                  pin: FieldType<Uint8Array>;
                  source: FieldType<DoorLock.EventSource>;
                  timestamp: FieldType<number>;
                  userId: FieldType<number>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      logging: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              getPinCode: Command<TypeFromFields<{
                  userId: FieldType<number>;
              }>, TypeFromFields<{
                  pinCode: FieldType<null | Uint8Array>;
                  userId: FieldType<number>;
                  userStatus: FieldType<null | DoorLock.UserStatus>;
                  userType: FieldType<null | DoorLock.UserType>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      pinCredential: boolean;
                      user: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              getRfidCode: Command<TypeFromFields<{
                  userId: FieldType<number>;
              }>, TypeFromFields<{
                  rfidCode: FieldType<null | Uint8Array>;
                  userId: FieldType<number>;
                  userStatus: FieldType<null | DoorLock.UserStatus>;
                  userType: FieldType<null | DoorLock.UserType>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      rfidCredential: boolean;
                      user: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              getUser: Command<TypeFromFields<{
                  userIndex: FieldType<number>;
              }>, TypeFromFields<{
                  creatorFabricIndex: FieldType<null | FabricIndex>;
                  credentialRule: FieldType<null | DoorLock.CredentialRule>;
                  credentials: FieldType<null | (...)[]>;
                  lastModifiedFabricIndex: FieldType<null | FabricIndex>;
                  nextUserIndex: FieldType<null | number>;
                  userIndex: FieldType<number>;
                  userName: FieldType<null | string>;
                  userStatus: FieldType<null | DoorLock.UserStatus>;
                  userType: FieldType<null | DoorLock.UserType>;
                  userUniqueId: FieldType<null | number>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      user: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              getUserStatus: OptionalCommand<TypeFromFields<{
                  userId: FieldType<number>;
              }>, TypeFromFields<{
                  userId: FieldType<number>;
                  userStatus: FieldType<DoorLock.UserStatus>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      fingerCredentials: boolean;
                      pinCredential: boolean;
                      rfidCredential: boolean;
                      user: boolean;
                  }];
              };
              getUserType: OptionalCommand<TypeFromFields<{
                  userId: FieldType<number>;
              }>, TypeFromFields<{
                  userId: FieldType<number>;
                  userType: FieldType<DoorLock.UserType>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      fingerCredentials: boolean;
                      pinCredential: boolean;
                      rfidCredential: boolean;
                      user: boolean;
                  }];
              };
              getWeekDaySchedule: Command<TypeFromFields<{
                  userIndexUserId: FieldType<number>;
                  weekDayIndex: FieldType<number>;
              }>, TypeFromFields<{
                  daysMask: OptionalFieldType<TypeFromPartialBitSchema<{
                      friday: ...;
                      monday: ...;
                      saturday: ...;
                      sunday: ...;
                      thursday: ...;
                      tuesday: ...;
                      wednesday: ...;
                  }>>;
                  endHour: OptionalFieldType<number>;
                  endMinute: OptionalFieldType<number>;
                  startHour: OptionalFieldType<number>;
                  startMinute: OptionalFieldType<number>;
                  status: FieldType<Status>;
                  userIndexUserId: FieldType<number>;
                  weekDayIndex: FieldType<number>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      weekDayAccessSchedules: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              getYearDaySchedule: Command<TypeFromFields<{
                  userIndexUserId: FieldType<number>;
                  yearDayIndex: FieldType<number>;
              }>, TypeFromFields<{
                  localEndTime: OptionalFieldType<number>;
                  localStartTime: OptionalFieldType<number>;
                  status: FieldType<Status>;
                  userIndexUserId: FieldType<number>;
                  yearDayIndex: FieldType<number>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      yearDayAccessSchedules: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              lockDoor: Command<TypeFromFields<{
                  pinCode: OptionalFieldType<Uint8Array>;
              }>, void, any>;
              setCredential: Command<TypeFromFields<{
                  credential: FieldType<TypeFromFields<{
                      credentialIndex: ...;
                      credentialType: ...;
                  }>>;
                  credentialData: FieldType<Uint8Array>;
                  operationType: FieldType<DoorLock.DataOperationType>;
                  userIndex: FieldType<null | number>;
                  userStatus: FieldType<null | DoorLock.UserStatus>;
                  userType: FieldType<null | DoorLock.UserType>;
              }>, TypeFromFields<{
                  nextCredentialIndex: OptionalFieldType<null | number>;
                  status: FieldType<Status>;
                  userIndex: FieldType<null | number>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      user: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              setHolidaySchedule: Command<TypeFromFields<{
                  holidayIndex: FieldType<number>;
                  localEndTime: FieldType<number>;
                  localStartTime: FieldType<number>;
                  operatingMode: FieldType<DoorLock.OperatingMode>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      holidaySchedules: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              setPinCode: Command<TypeFromFields<{
                  pin: FieldType<Uint8Array>;
                  userId: FieldType<number>;
                  userStatus: FieldType<null | DoorLock.UserStatus>;
                  userType: FieldType<null | DoorLock.UserType>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      pinCredential: boolean;
                      user: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              setRfidCode: Command<TypeFromFields<{
                  rfidCode: FieldType<Uint8Array>;
                  userId: FieldType<number>;
                  userStatus: FieldType<null | DoorLock.UserStatus>;
                  userType: FieldType<null | DoorLock.UserType>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      rfidCredential: boolean;
                      user: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              setUser: Command<TypeFromFields<{
                  credentialRule: FieldType<null | DoorLock.CredentialRule>;
                  operationType: FieldType<DoorLock.DataOperationType>;
                  userIndex: FieldType<number>;
                  userName: FieldType<null | string>;
                  userStatus: FieldType<null | DoorLock.UserStatus>;
                  userType: FieldType<null | DoorLock.UserType>;
                  userUniqueId: FieldType<null | number>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      user: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              setUserStatus: OptionalCommand<TypeFromFields<{
                  userId: FieldType<number>;
                  userStatus: FieldType<DoorLock.UserStatus>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      fingerCredentials: boolean;
                      pinCredential: boolean;
                      rfidCredential: boolean;
                      user: boolean;
                  }];
              };
              setUserType: OptionalCommand<TypeFromFields<{
                  userId: FieldType<number>;
                  userType: FieldType<DoorLock.UserType>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      fingerCredentials: boolean;
                      pinCredential: boolean;
                      rfidCredential: boolean;
                      user: boolean;
                  }];
              };
              setWeekDaySchedule: Command<TypeFromFields<{
                  daysMask: FieldType<TypeFromPartialBitSchema<{
                      friday: ...;
                      monday: ...;
                      saturday: ...;
                      sunday: ...;
                      thursday: ...;
                      tuesday: ...;
                      wednesday: ...;
                  }>>;
                  endHour: FieldType<number>;
                  endMinute: FieldType<number>;
                  startHour: FieldType<number>;
                  startMinute: FieldType<number>;
                  userIndexUserId: FieldType<number>;
                  weekDayIndex: FieldType<number>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      weekDayAccessSchedules: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              setYearDaySchedule: Command<TypeFromFields<{
                  localEndTime: FieldType<number>;
                  localStartTime: FieldType<number>;
                  userIndexUserId: FieldType<number>;
                  yearDayIndex: FieldType<number>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      yearDayAccessSchedules: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              unboltDoor: Command<TypeFromFields<{
                  pinCode: OptionalFieldType<Uint8Array>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      unbolting: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              unlockDoor: Command<TypeFromFields<{
                  pinCode: OptionalFieldType<Uint8Array>;
              }>, void, any>;
              unlockWithTimeout: OptionalCommand<TypeFromFields<{
                  pinCode: OptionalFieldType<Uint8Array>;
                  timeout: FieldType<number>;
              }>, void, any>;
          };
          events: {
              doorLockAlarm: Event<TypeFromFields<{
                  alarmCode: FieldType<DoorLock.AlarmCode>;
              }>, any>;
              doorStateChange: Event<TypeFromFields<{
                  doorState: FieldType<DoorLock.DoorState>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      doorPositionSensor: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              lockOperation: Event<TypeFromFields<{
                  credentials: OptionalFieldType<null | TypeFromFields<(...)>[]>;
                  fabricIndex: FieldType<null | FabricIndex>;
                  lockOperationType: FieldType<DoorLock.LockOperationType>;
                  operationSource: FieldType<DoorLock.OperationSource>;
                  sourceNode: FieldType<null | NodeId>;
                  userIndex: FieldType<null | number>;
              }>, any>;
              lockOperationError: Event<TypeFromFields<{
                  credentials: OptionalFieldType<null | TypeFromFields<(...)>[]>;
                  fabricIndex: FieldType<null | FabricIndex>;
                  lockOperationType: FieldType<DoorLock.LockOperationType>;
                  operationError: FieldType<DoorLock.OperationError>;
                  operationSource: FieldType<DoorLock.OperationSource>;
                  sourceNode: FieldType<null | NodeId>;
                  userIndex: FieldType<null | number>;
              }>, any>;
              lockUserChange: Event<TypeFromFields<{
                  dataIndex: FieldType<null | number>;
                  dataOperationType: FieldType<DoorLock.DataOperationType>;
                  fabricIndex: FieldType<null | FabricIndex>;
                  lockDataType: FieldType<DoorLock.LockDataType>;
                  operationSource: FieldType<DoorLock.OperationSource>;
                  sourceNode: FieldType<null | NodeId>;
                  userIndex: FieldType<null | number>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      user: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
          };
          features: {
              credentialOverTheAirAccess: BitFlag;
              doorPositionSensor: BitFlag;
              faceCredentials: BitFlag;
              fingerCredentials: BitFlag;
              holidaySchedules: BitFlag;
              logging: BitFlag;
              notification: BitFlag;
              pinCredential: BitFlag;
              rfidCredential: BitFlag;
              unbolting: BitFlag;
              user: BitFlag;
              weekDayAccessSchedules: BitFlag;
              yearDayAccessSchedules: BitFlag;
          };
          id: Branded<257, "ClusterId">;
          name: "DoorLock";
          revision: 7;
      }>>

    Parameters

    Returns WithAlterations<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            actuatorEnabled: Attribute<boolean, any>;
            alarmMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                doorForcedOpen: BitFlag;
                frontEscutcheonRemoved: BitFlag;
                lockFactoryReset: BitFlag;
                lockJammed: BitFlag;
                lockRadioPowerCycled: BitFlag;
                na: BitFlag;
                wrongCodeEntryLimit: BitFlag;
            }>, any>;
            attributeList: Attribute<AttributeId[], never>;
            autoRelockTime: OptionalWritableAttribute<number, any>;
            clusterRevision: Attribute<number, never>;
            credentialRulesSupport: FixedAttribute<TypeFromPartialBitSchema<{
                dual: BitFlag;
                single: BitFlag;
                tri: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            defaultConfigurationRegister: OptionalAttribute<TypeFromPartialBitSchema<{
                autoRelockTime: BitFlag;
                keypadInterface: BitFlag;
                ledSettings: BitFlag;
                localProgramming: BitFlag;
                remoteInterface: BitFlag;
                soundVolume: BitFlag;
            }>, any>;
            doorClosedEvents: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    doorPositionSensor: boolean;
                }];
            };
            doorOpenEvents: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    doorPositionSensor: boolean;
                }];
            };
            doorState: Attribute<null | DoorLock.DoorState, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    doorPositionSensor: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            enableInsideStatusLed: OptionalWritableAttribute<boolean, any>;
            enableLocalProgramming: OptionalWritableAttribute<boolean, any>;
            enableLogging: WritableAttribute<boolean, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    logging: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            enableOneTouchLocking: OptionalWritableAttribute<boolean, any>;
            enablePrivacyModeButton: OptionalWritableAttribute<boolean, any>;
            expiringUserTimeout: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    user: boolean;
                }];
            };
            featureMap: Attribute<TypeFromPartialBitSchema<{
                credentialOverTheAirAccess: BitFlag;
                doorPositionSensor: BitFlag;
                faceCredentials: BitFlag;
                fingerCredentials: BitFlag;
                holidaySchedules: BitFlag;
                logging: BitFlag;
                notification: BitFlag;
                pinCredential: BitFlag;
                rfidCredential: BitFlag;
                unbolting: BitFlag;
                user: BitFlag;
                weekDayAccessSchedules: BitFlag;
                yearDayAccessSchedules: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            keypadOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                bit0: BitFlag;
                bit1: BitFlag;
                bit10: BitFlag;
                bit11: BitFlag;
                bit12: BitFlag;
                bit13: BitFlag;
                bit14: BitFlag;
                bit15: BitFlag;
                bit2: BitFlag;
                bit3: BitFlag;
                bit4: BitFlag;
                bit5: BitFlag;
                bit6: BitFlag;
                bit7: BitFlag;
                bit8: BitFlag;
                bit9: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                    pinCredential: boolean;
                }];
            };
            keypadProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                pinAdded: BitFlag;
                pinChanged: BitFlag;
                pinCleared: BitFlag;
                pinCodeChanged: BitFlag;
                unknown: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                    pinCredential: boolean;
                }];
            };
            language: OptionalWritableAttribute<string, any>;
            ledSettings: OptionalWritableAttribute<DoorLock.LedSetting, any>;
            localProgrammingFeatures: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                addUsersCredentialsSchedules: BitFlag;
                adjustSettings: BitFlag;
                clearUsersCredentialsSchedules: BitFlag;
                modifyUsersCredentialsSchedules: BitFlag;
            }>, any>;
            lockState: Attribute<null | DoorLock.LockState, any>;
            lockType: Attribute<DoorLock.LockType, any>;
            manualOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                bit0: BitFlag;
                bit1: BitFlag;
                bit10: BitFlag;
                bit11: BitFlag;
                bit12: BitFlag;
                bit13: BitFlag;
                bit14: BitFlag;
                bit15: BitFlag;
                bit2: BitFlag;
                bit3: BitFlag;
                bit4: BitFlag;
                bit5: BitFlag;
                bit6: BitFlag;
                bit7: BitFlag;
                bit8: BitFlag;
                bit9: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                }];
            };
            maxPinCodeLength: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            maxRfidCodeLength: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minPinCodeLength: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minRfidCodeLength: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfCredentialsSupportedPerUser: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfHolidaySchedulesSupported: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    holidaySchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfLogRecordsSupported: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    logging: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfPinUsersSupported: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfRfidUsersSupported: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfTotalUsersSupported: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfWeekDaySchedulesSupportedPerUser: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    weekDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfYearDaySchedulesSupportedPerUser: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    yearDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            openPeriod: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    doorPositionSensor: boolean;
                }];
            };
            operatingMode: WritableAttribute<DoorLock.OperatingMode, any>;
            remoteOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                bit0: BitFlag;
                bit1: BitFlag;
                bit10: BitFlag;
                bit11: BitFlag;
                bit12: BitFlag;
                bit13: BitFlag;
                bit14: BitFlag;
                bit15: BitFlag;
                bit2: BitFlag;
                bit3: BitFlag;
                bit4: BitFlag;
                bit5: BitFlag;
                bit6: BitFlag;
                bit7: BitFlag;
                bit8: BitFlag;
                bit9: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                }];
            };
            remoteProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                pinAdded: BitFlag;
                pinChanged: BitFlag;
                pinCleared: BitFlag;
                rfidCodeAdded: BitFlag;
                rfidCodeCleared: BitFlag;
                unknown: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                }];
            };
            requirePinForRemoteOperation: WritableAttribute<boolean, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    credentialOverTheAirAccess: boolean;
                    pinCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            rfidOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                bit0: BitFlag;
                bit1: BitFlag;
                bit10: BitFlag;
                bit11: BitFlag;
                bit12: BitFlag;
                bit13: BitFlag;
                bit14: BitFlag;
                bit15: BitFlag;
                bit2: BitFlag;
                bit3: BitFlag;
                bit4: BitFlag;
                bit5: BitFlag;
                bit6: BitFlag;
                bit7: BitFlag;
                bit8: BitFlag;
                bit9: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                    rfidCredential: boolean;
                }];
            };
            rfidProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                idAdded: BitFlag;
                idCleared: BitFlag;
                unknown: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                    rfidCredential: boolean;
                }];
            };
            sendPinOverTheAir: OptionalWritableAttribute<boolean, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    pinCredential: boolean;
                    user: boolean;
                }];
            };
            soundVolume: OptionalWritableAttribute<DoorLock.SoundVolume, any>;
            supportedOperatingModes: FixedAttribute<TypeFromPartialBitSchema<{
                noRemoteLockUnlock: BitFlag;
                normal: BitFlag;
                passage: BitFlag;
                privacy: BitFlag;
                vacation: BitFlag;
            }>, any>;
            userCodeTemporaryDisableTime: WritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                }, {
                    rfidCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            wrongCodeEntryLimit: WritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                }, {
                    rfidCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            clearAllPinCodes: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearAllRfidCodes: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearCredential: Command<TypeFromFields<{
                credential: FieldType<null | TypeFromFields<(...)>>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearHolidaySchedule: Command<TypeFromFields<{
                holidayIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    holidaySchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearPinCode: Command<TypeFromFields<{
                pinSlotIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearRfidCode: Command<TypeFromFields<{
                rfidSlotIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearUser: Command<TypeFromFields<{
                userIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearWeekDaySchedule: Command<TypeFromFields<{
                userIndexUserId: FieldType<number>;
                weekDayIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    weekDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearYearDaySchedule: Command<TypeFromFields<{
                userIndexUserId: FieldType<number>;
                yearDayIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    yearDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getCredentialStatus: Command<TypeFromFields<{
                credential: FieldType<TypeFromFields<{
                    credentialIndex: ...;
                    credentialType: ...;
                }>>;
            }>, TypeFromFields<{
                creatorFabricIndex: FieldType<null | FabricIndex>;
                credentialExists: FieldType<boolean>;
                lastModifiedFabricIndex: FieldType<null | FabricIndex>;
                nextCredentialIndex: OptionalFieldType<null | number>;
                userIndex: FieldType<null | number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getHolidaySchedule: Command<TypeFromFields<{
                holidayIndex: FieldType<number>;
            }>, TypeFromFields<{
                holidayIndex: FieldType<number>;
                localEndTime: OptionalFieldType<null | number>;
                localStartTime: OptionalFieldType<null | number>;
                operatingMode: OptionalFieldType<null | DoorLock.OperatingMode>;
                status: FieldType<Status>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    holidaySchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getLogRecord: Command<TypeFromFields<{
                logIndex: FieldType<number>;
            }>, TypeFromFields<{
                eventId: FieldType<number>;
                eventType: FieldType<DoorLock.EventType>;
                logEntryId: FieldType<number>;
                pin: FieldType<Uint8Array>;
                source: FieldType<DoorLock.EventSource>;
                timestamp: FieldType<number>;
                userId: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    logging: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getPinCode: Command<TypeFromFields<{
                userId: FieldType<number>;
            }>, TypeFromFields<{
                pinCode: FieldType<null | Uint8Array>;
                userId: FieldType<number>;
                userStatus: FieldType<null | DoorLock.UserStatus>;
                userType: FieldType<null | DoorLock.UserType>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getRfidCode: Command<TypeFromFields<{
                userId: FieldType<number>;
            }>, TypeFromFields<{
                rfidCode: FieldType<null | Uint8Array>;
                userId: FieldType<number>;
                userStatus: FieldType<null | DoorLock.UserStatus>;
                userType: FieldType<null | DoorLock.UserType>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getUser: Command<TypeFromFields<{
                userIndex: FieldType<number>;
            }>, TypeFromFields<{
                creatorFabricIndex: FieldType<null | FabricIndex>;
                credentialRule: FieldType<null | DoorLock.CredentialRule>;
                credentials: FieldType<null | (...)[]>;
                lastModifiedFabricIndex: FieldType<null | FabricIndex>;
                nextUserIndex: FieldType<null | number>;
                userIndex: FieldType<number>;
                userName: FieldType<null | string>;
                userStatus: FieldType<null | DoorLock.UserStatus>;
                userType: FieldType<null | DoorLock.UserType>;
                userUniqueId: FieldType<null | number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getUserStatus: OptionalCommand<TypeFromFields<{
                userId: FieldType<number>;
            }>, TypeFromFields<{
                userId: FieldType<number>;
                userStatus: FieldType<DoorLock.UserStatus>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    fingerCredentials: boolean;
                    pinCredential: boolean;
                    rfidCredential: boolean;
                    user: boolean;
                }];
            };
            getUserType: OptionalCommand<TypeFromFields<{
                userId: FieldType<number>;
            }>, TypeFromFields<{
                userId: FieldType<number>;
                userType: FieldType<DoorLock.UserType>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    fingerCredentials: boolean;
                    pinCredential: boolean;
                    rfidCredential: boolean;
                    user: boolean;
                }];
            };
            getWeekDaySchedule: Command<TypeFromFields<{
                userIndexUserId: FieldType<number>;
                weekDayIndex: FieldType<number>;
            }>, TypeFromFields<{
                daysMask: OptionalFieldType<TypeFromPartialBitSchema<{
                    friday: ...;
                    monday: ...;
                    saturday: ...;
                    sunday: ...;
                    thursday: ...;
                    tuesday: ...;
                    wednesday: ...;
                }>>;
                endHour: OptionalFieldType<number>;
                endMinute: OptionalFieldType<number>;
                startHour: OptionalFieldType<number>;
                startMinute: OptionalFieldType<number>;
                status: FieldType<Status>;
                userIndexUserId: FieldType<number>;
                weekDayIndex: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    weekDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getYearDaySchedule: Command<TypeFromFields<{
                userIndexUserId: FieldType<number>;
                yearDayIndex: FieldType<number>;
            }>, TypeFromFields<{
                localEndTime: OptionalFieldType<number>;
                localStartTime: OptionalFieldType<number>;
                status: FieldType<Status>;
                userIndexUserId: FieldType<number>;
                yearDayIndex: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    yearDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            lockDoor: Command<TypeFromFields<{
                pinCode: OptionalFieldType<Uint8Array>;
            }>, void, any>;
            setCredential: Command<TypeFromFields<{
                credential: FieldType<TypeFromFields<{
                    credentialIndex: ...;
                    credentialType: ...;
                }>>;
                credentialData: FieldType<Uint8Array>;
                operationType: FieldType<DoorLock.DataOperationType>;
                userIndex: FieldType<null | number>;
                userStatus: FieldType<null | DoorLock.UserStatus>;
                userType: FieldType<null | DoorLock.UserType>;
            }>, TypeFromFields<{
                nextCredentialIndex: OptionalFieldType<null | number>;
                status: FieldType<Status>;
                userIndex: FieldType<null | number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setHolidaySchedule: Command<TypeFromFields<{
                holidayIndex: FieldType<number>;
                localEndTime: FieldType<number>;
                localStartTime: FieldType<number>;
                operatingMode: FieldType<DoorLock.OperatingMode>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    holidaySchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setPinCode: Command<TypeFromFields<{
                pin: FieldType<Uint8Array>;
                userId: FieldType<number>;
                userStatus: FieldType<null | DoorLock.UserStatus>;
                userType: FieldType<null | DoorLock.UserType>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setRfidCode: Command<TypeFromFields<{
                rfidCode: FieldType<Uint8Array>;
                userId: FieldType<number>;
                userStatus: FieldType<null | DoorLock.UserStatus>;
                userType: FieldType<null | DoorLock.UserType>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setUser: Command<TypeFromFields<{
                credentialRule: FieldType<null | DoorLock.CredentialRule>;
                operationType: FieldType<DoorLock.DataOperationType>;
                userIndex: FieldType<number>;
                userName: FieldType<null | string>;
                userStatus: FieldType<null | DoorLock.UserStatus>;
                userType: FieldType<null | DoorLock.UserType>;
                userUniqueId: FieldType<null | number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setUserStatus: OptionalCommand<TypeFromFields<{
                userId: FieldType<number>;
                userStatus: FieldType<DoorLock.UserStatus>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    fingerCredentials: boolean;
                    pinCredential: boolean;
                    rfidCredential: boolean;
                    user: boolean;
                }];
            };
            setUserType: OptionalCommand<TypeFromFields<{
                userId: FieldType<number>;
                userType: FieldType<DoorLock.UserType>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    fingerCredentials: boolean;
                    pinCredential: boolean;
                    rfidCredential: boolean;
                    user: boolean;
                }];
            };
            setWeekDaySchedule: Command<TypeFromFields<{
                daysMask: FieldType<TypeFromPartialBitSchema<{
                    friday: ...;
                    monday: ...;
                    saturday: ...;
                    sunday: ...;
                    thursday: ...;
                    tuesday: ...;
                    wednesday: ...;
                }>>;
                endHour: FieldType<number>;
                endMinute: FieldType<number>;
                startHour: FieldType<number>;
                startMinute: FieldType<number>;
                userIndexUserId: FieldType<number>;
                weekDayIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    weekDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setYearDaySchedule: Command<TypeFromFields<{
                localEndTime: FieldType<number>;
                localStartTime: FieldType<number>;
                userIndexUserId: FieldType<number>;
                yearDayIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    yearDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            unboltDoor: Command<TypeFromFields<{
                pinCode: OptionalFieldType<Uint8Array>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    unbolting: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            unlockDoor: Command<TypeFromFields<{
                pinCode: OptionalFieldType<Uint8Array>;
            }>, void, any>;
            unlockWithTimeout: OptionalCommand<TypeFromFields<{
                pinCode: OptionalFieldType<Uint8Array>;
                timeout: FieldType<number>;
            }>, void, any>;
        };
        events: {
            doorLockAlarm: Event<TypeFromFields<{
                alarmCode: FieldType<DoorLock.AlarmCode>;
            }>, any>;
            doorStateChange: Event<TypeFromFields<{
                doorState: FieldType<DoorLock.DoorState>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    doorPositionSensor: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            lockOperation: Event<TypeFromFields<{
                credentials: OptionalFieldType<null | TypeFromFields<(...)>[]>;
                fabricIndex: FieldType<null | FabricIndex>;
                lockOperationType: FieldType<DoorLock.LockOperationType>;
                operationSource: FieldType<DoorLock.OperationSource>;
                sourceNode: FieldType<null | NodeId>;
                userIndex: FieldType<null | number>;
            }>, any>;
            lockOperationError: Event<TypeFromFields<{
                credentials: OptionalFieldType<null | TypeFromFields<(...)>[]>;
                fabricIndex: FieldType<null | FabricIndex>;
                lockOperationType: FieldType<DoorLock.LockOperationType>;
                operationError: FieldType<DoorLock.OperationError>;
                operationSource: FieldType<DoorLock.OperationSource>;
                sourceNode: FieldType<null | NodeId>;
                userIndex: FieldType<null | number>;
            }>, any>;
            lockUserChange: Event<TypeFromFields<{
                dataIndex: FieldType<null | number>;
                dataOperationType: FieldType<DoorLock.DataOperationType>;
                fabricIndex: FieldType<null | FabricIndex>;
                lockDataType: FieldType<DoorLock.LockDataType>;
                operationSource: FieldType<DoorLock.OperationSource>;
                sourceNode: FieldType<null | NodeId>;
                userIndex: FieldType<null | number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            credentialOverTheAirAccess: BitFlag;
            doorPositionSensor: BitFlag;
            faceCredentials: BitFlag;
            fingerCredentials: BitFlag;
            holidaySchedules: BitFlag;
            logging: BitFlag;
            notification: BitFlag;
            pinCredential: BitFlag;
            rfidCredential: BitFlag;
            unbolting: BitFlag;
            user: BitFlag;
            weekDayAccessSchedules: BitFlag;
            yearDayAccessSchedules: BitFlag;
        };
        id: Branded<257, "ClusterId">;
        name: "DoorLock";
        revision: 7;
    }>, AlterationsT>

  • Modify elements using ElementModifier.enable.

    Type Parameters

    • const FlagsT extends ElementFlags<Of<{
          attributes: {
              acceptedCommandList: Attribute<CommandId[], never>;
              actuatorEnabled: Attribute<boolean, any>;
              alarmMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                  doorForcedOpen: BitFlag;
                  frontEscutcheonRemoved: BitFlag;
                  lockFactoryReset: BitFlag;
                  lockJammed: BitFlag;
                  lockRadioPowerCycled: BitFlag;
                  na: BitFlag;
                  wrongCodeEntryLimit: BitFlag;
              }>, any>;
              attributeList: Attribute<AttributeId[], never>;
              autoRelockTime: OptionalWritableAttribute<number, any>;
              clusterRevision: Attribute<number, never>;
              credentialRulesSupport: FixedAttribute<TypeFromPartialBitSchema<{
                  dual: BitFlag;
                  single: BitFlag;
                  tri: BitFlag;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      user: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              defaultConfigurationRegister: OptionalAttribute<TypeFromPartialBitSchema<{
                  autoRelockTime: BitFlag;
                  keypadInterface: BitFlag;
                  ledSettings: BitFlag;
                  localProgramming: BitFlag;
                  remoteInterface: BitFlag;
                  soundVolume: BitFlag;
              }>, any>;
              doorClosedEvents: OptionalWritableAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      doorPositionSensor: boolean;
                  }];
              };
              doorOpenEvents: OptionalWritableAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      doorPositionSensor: boolean;
                  }];
              };
              doorState: Attribute<null | DoorLock.DoorState, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      doorPositionSensor: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              enableInsideStatusLed: OptionalWritableAttribute<boolean, any>;
              enableLocalProgramming: OptionalWritableAttribute<boolean, any>;
              enableLogging: WritableAttribute<boolean, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      logging: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              enableOneTouchLocking: OptionalWritableAttribute<boolean, any>;
              enablePrivacyModeButton: OptionalWritableAttribute<boolean, any>;
              expiringUserTimeout: OptionalWritableAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      user: boolean;
                  }];
              };
              featureMap: Attribute<TypeFromPartialBitSchema<{
                  credentialOverTheAirAccess: BitFlag;
                  doorPositionSensor: BitFlag;
                  faceCredentials: BitFlag;
                  fingerCredentials: BitFlag;
                  holidaySchedules: BitFlag;
                  logging: BitFlag;
                  notification: BitFlag;
                  pinCredential: BitFlag;
                  rfidCredential: BitFlag;
                  unbolting: BitFlag;
                  user: BitFlag;
                  weekDayAccessSchedules: BitFlag;
                  yearDayAccessSchedules: BitFlag;
              }>, never>;
              generatedCommandList: Attribute<CommandId[], never>;
              keypadOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                  bit0: BitFlag;
                  bit1: BitFlag;
                  bit10: BitFlag;
                  bit11: BitFlag;
                  bit12: BitFlag;
                  bit13: BitFlag;
                  bit14: BitFlag;
                  bit15: BitFlag;
                  bit2: BitFlag;
                  bit3: BitFlag;
                  bit4: BitFlag;
                  bit5: BitFlag;
                  bit6: BitFlag;
                  bit7: BitFlag;
                  bit8: BitFlag;
                  bit9: BitFlag;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      notification: boolean;
                      pinCredential: boolean;
                  }];
              };
              keypadProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                  pinAdded: BitFlag;
                  pinChanged: BitFlag;
                  pinCleared: BitFlag;
                  pinCodeChanged: BitFlag;
                  unknown: BitFlag;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      notification: boolean;
                      pinCredential: boolean;
                  }];
              };
              language: OptionalWritableAttribute<string, any>;
              ledSettings: OptionalWritableAttribute<DoorLock.LedSetting, any>;
              localProgrammingFeatures: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                  addUsersCredentialsSchedules: BitFlag;
                  adjustSettings: BitFlag;
                  clearUsersCredentialsSchedules: BitFlag;
                  modifyUsersCredentialsSchedules: BitFlag;
              }>, any>;
              lockState: Attribute<null | DoorLock.LockState, any>;
              lockType: Attribute<DoorLock.LockType, any>;
              manualOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                  bit0: BitFlag;
                  bit1: BitFlag;
                  bit10: BitFlag;
                  bit11: BitFlag;
                  bit12: BitFlag;
                  bit13: BitFlag;
                  bit14: BitFlag;
                  bit15: BitFlag;
                  bit2: BitFlag;
                  bit3: BitFlag;
                  bit4: BitFlag;
                  bit5: BitFlag;
                  bit6: BitFlag;
                  bit7: BitFlag;
                  bit8: BitFlag;
                  bit9: BitFlag;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      notification: boolean;
                  }];
              };
              maxPinCodeLength: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      pinCredential: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              maxRfidCodeLength: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      rfidCredential: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              minPinCodeLength: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      pinCredential: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              minRfidCodeLength: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      rfidCredential: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              numberOfCredentialsSupportedPerUser: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      user: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              numberOfHolidaySchedulesSupported: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      holidaySchedules: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              numberOfLogRecordsSupported: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      logging: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              numberOfPinUsersSupported: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      pinCredential: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              numberOfRfidUsersSupported: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      rfidCredential: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              numberOfTotalUsersSupported: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      user: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              numberOfWeekDaySchedulesSupportedPerUser: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      weekDayAccessSchedules: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              numberOfYearDaySchedulesSupportedPerUser: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      yearDayAccessSchedules: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              openPeriod: OptionalWritableAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      doorPositionSensor: boolean;
                  }];
              };
              operatingMode: WritableAttribute<DoorLock.OperatingMode, any>;
              remoteOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                  bit0: BitFlag;
                  bit1: BitFlag;
                  bit10: BitFlag;
                  bit11: BitFlag;
                  bit12: BitFlag;
                  bit13: BitFlag;
                  bit14: BitFlag;
                  bit15: BitFlag;
                  bit2: BitFlag;
                  bit3: BitFlag;
                  bit4: BitFlag;
                  bit5: BitFlag;
                  bit6: BitFlag;
                  bit7: BitFlag;
                  bit8: BitFlag;
                  bit9: BitFlag;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      notification: boolean;
                  }];
              };
              remoteProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                  pinAdded: BitFlag;
                  pinChanged: BitFlag;
                  pinCleared: BitFlag;
                  rfidCodeAdded: BitFlag;
                  rfidCodeCleared: BitFlag;
                  unknown: BitFlag;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      notification: boolean;
                  }];
              };
              requirePinForRemoteOperation: WritableAttribute<boolean, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      credentialOverTheAirAccess: boolean;
                      pinCredential: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              rfidOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                  bit0: BitFlag;
                  bit1: BitFlag;
                  bit10: BitFlag;
                  bit11: BitFlag;
                  bit12: BitFlag;
                  bit13: BitFlag;
                  bit14: BitFlag;
                  bit15: BitFlag;
                  bit2: BitFlag;
                  bit3: BitFlag;
                  bit4: BitFlag;
                  bit5: BitFlag;
                  bit6: BitFlag;
                  bit7: BitFlag;
                  bit8: BitFlag;
                  bit9: BitFlag;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      notification: boolean;
                      rfidCredential: boolean;
                  }];
              };
              rfidProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                  idAdded: BitFlag;
                  idCleared: BitFlag;
                  unknown: BitFlag;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      notification: boolean;
                      rfidCredential: boolean;
                  }];
              };
              sendPinOverTheAir: OptionalWritableAttribute<boolean, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      pinCredential: boolean;
                      user: boolean;
                  }];
              };
              soundVolume: OptionalWritableAttribute<DoorLock.SoundVolume, any>;
              supportedOperatingModes: FixedAttribute<TypeFromPartialBitSchema<{
                  noRemoteLockUnlock: BitFlag;
                  normal: BitFlag;
                  passage: BitFlag;
                  privacy: BitFlag;
                  vacation: BitFlag;
              }>, any>;
              userCodeTemporaryDisableTime: WritableAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      pinCredential: boolean;
                  }, {
                      rfidCredential: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              wrongCodeEntryLimit: WritableAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      pinCredential: boolean;
                  }, {
                      rfidCredential: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
          };
          commands: {
              clearAllPinCodes: Command<void, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      pinCredential: boolean;
                      user: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              clearAllRfidCodes: Command<void, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      rfidCredential: boolean;
                      user: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              clearCredential: Command<TypeFromFields<{
                  credential: FieldType<null | TypeFromFields<(...)>>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      user: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              clearHolidaySchedule: Command<TypeFromFields<{
                  holidayIndex: FieldType<number>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      holidaySchedules: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              clearPinCode: Command<TypeFromFields<{
                  pinSlotIndex: FieldType<number>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      pinCredential: boolean;
                      user: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              clearRfidCode: Command<TypeFromFields<{
                  rfidSlotIndex: FieldType<number>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      rfidCredential: boolean;
                      user: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              clearUser: Command<TypeFromFields<{
                  userIndex: FieldType<number>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      user: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              clearWeekDaySchedule: Command<TypeFromFields<{
                  userIndexUserId: FieldType<number>;
                  weekDayIndex: FieldType<number>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      weekDayAccessSchedules: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              clearYearDaySchedule: Command<TypeFromFields<{
                  userIndexUserId: FieldType<number>;
                  yearDayIndex: FieldType<number>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      yearDayAccessSchedules: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              getCredentialStatus: Command<TypeFromFields<{
                  credential: FieldType<TypeFromFields<{
                      credentialIndex: ...;
                      credentialType: ...;
                  }>>;
              }>, TypeFromFields<{
                  creatorFabricIndex: FieldType<null | FabricIndex>;
                  credentialExists: FieldType<boolean>;
                  lastModifiedFabricIndex: FieldType<null | FabricIndex>;
                  nextCredentialIndex: OptionalFieldType<null | number>;
                  userIndex: FieldType<null | number>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      user: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              getHolidaySchedule: Command<TypeFromFields<{
                  holidayIndex: FieldType<number>;
              }>, TypeFromFields<{
                  holidayIndex: FieldType<number>;
                  localEndTime: OptionalFieldType<null | number>;
                  localStartTime: OptionalFieldType<null | number>;
                  operatingMode: OptionalFieldType<null | DoorLock.OperatingMode>;
                  status: FieldType<Status>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      holidaySchedules: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              getLogRecord: Command<TypeFromFields<{
                  logIndex: FieldType<number>;
              }>, TypeFromFields<{
                  eventId: FieldType<number>;
                  eventType: FieldType<DoorLock.EventType>;
                  logEntryId: FieldType<number>;
                  pin: FieldType<Uint8Array>;
                  source: FieldType<DoorLock.EventSource>;
                  timestamp: FieldType<number>;
                  userId: FieldType<number>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      logging: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              getPinCode: Command<TypeFromFields<{
                  userId: FieldType<number>;
              }>, TypeFromFields<{
                  pinCode: FieldType<null | Uint8Array>;
                  userId: FieldType<number>;
                  userStatus: FieldType<null | DoorLock.UserStatus>;
                  userType: FieldType<null | DoorLock.UserType>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      pinCredential: boolean;
                      user: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              getRfidCode: Command<TypeFromFields<{
                  userId: FieldType<number>;
              }>, TypeFromFields<{
                  rfidCode: FieldType<null | Uint8Array>;
                  userId: FieldType<number>;
                  userStatus: FieldType<null | DoorLock.UserStatus>;
                  userType: FieldType<null | DoorLock.UserType>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      rfidCredential: boolean;
                      user: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              getUser: Command<TypeFromFields<{
                  userIndex: FieldType<number>;
              }>, TypeFromFields<{
                  creatorFabricIndex: FieldType<null | FabricIndex>;
                  credentialRule: FieldType<null | DoorLock.CredentialRule>;
                  credentials: FieldType<null | (...)[]>;
                  lastModifiedFabricIndex: FieldType<null | FabricIndex>;
                  nextUserIndex: FieldType<null | number>;
                  userIndex: FieldType<number>;
                  userName: FieldType<null | string>;
                  userStatus: FieldType<null | DoorLock.UserStatus>;
                  userType: FieldType<null | DoorLock.UserType>;
                  userUniqueId: FieldType<null | number>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      user: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              getUserStatus: OptionalCommand<TypeFromFields<{
                  userId: FieldType<number>;
              }>, TypeFromFields<{
                  userId: FieldType<number>;
                  userStatus: FieldType<DoorLock.UserStatus>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      fingerCredentials: boolean;
                      pinCredential: boolean;
                      rfidCredential: boolean;
                      user: boolean;
                  }];
              };
              getUserType: OptionalCommand<TypeFromFields<{
                  userId: FieldType<number>;
              }>, TypeFromFields<{
                  userId: FieldType<number>;
                  userType: FieldType<DoorLock.UserType>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      fingerCredentials: boolean;
                      pinCredential: boolean;
                      rfidCredential: boolean;
                      user: boolean;
                  }];
              };
              getWeekDaySchedule: Command<TypeFromFields<{
                  userIndexUserId: FieldType<number>;
                  weekDayIndex: FieldType<number>;
              }>, TypeFromFields<{
                  daysMask: OptionalFieldType<TypeFromPartialBitSchema<{
                      friday: ...;
                      monday: ...;
                      saturday: ...;
                      sunday: ...;
                      thursday: ...;
                      tuesday: ...;
                      wednesday: ...;
                  }>>;
                  endHour: OptionalFieldType<number>;
                  endMinute: OptionalFieldType<number>;
                  startHour: OptionalFieldType<number>;
                  startMinute: OptionalFieldType<number>;
                  status: FieldType<Status>;
                  userIndexUserId: FieldType<number>;
                  weekDayIndex: FieldType<number>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      weekDayAccessSchedules: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              getYearDaySchedule: Command<TypeFromFields<{
                  userIndexUserId: FieldType<number>;
                  yearDayIndex: FieldType<number>;
              }>, TypeFromFields<{
                  localEndTime: OptionalFieldType<number>;
                  localStartTime: OptionalFieldType<number>;
                  status: FieldType<Status>;
                  userIndexUserId: FieldType<number>;
                  yearDayIndex: FieldType<number>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      yearDayAccessSchedules: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              lockDoor: Command<TypeFromFields<{
                  pinCode: OptionalFieldType<Uint8Array>;
              }>, void, any>;
              setCredential: Command<TypeFromFields<{
                  credential: FieldType<TypeFromFields<{
                      credentialIndex: ...;
                      credentialType: ...;
                  }>>;
                  credentialData: FieldType<Uint8Array>;
                  operationType: FieldType<DoorLock.DataOperationType>;
                  userIndex: FieldType<null | number>;
                  userStatus: FieldType<null | DoorLock.UserStatus>;
                  userType: FieldType<null | DoorLock.UserType>;
              }>, TypeFromFields<{
                  nextCredentialIndex: OptionalFieldType<null | number>;
                  status: FieldType<Status>;
                  userIndex: FieldType<null | number>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      user: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              setHolidaySchedule: Command<TypeFromFields<{
                  holidayIndex: FieldType<number>;
                  localEndTime: FieldType<number>;
                  localStartTime: FieldType<number>;
                  operatingMode: FieldType<DoorLock.OperatingMode>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      holidaySchedules: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              setPinCode: Command<TypeFromFields<{
                  pin: FieldType<Uint8Array>;
                  userId: FieldType<number>;
                  userStatus: FieldType<null | DoorLock.UserStatus>;
                  userType: FieldType<null | DoorLock.UserType>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      pinCredential: boolean;
                      user: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              setRfidCode: Command<TypeFromFields<{
                  rfidCode: FieldType<Uint8Array>;
                  userId: FieldType<number>;
                  userStatus: FieldType<null | DoorLock.UserStatus>;
                  userType: FieldType<null | DoorLock.UserType>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      rfidCredential: boolean;
                      user: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              setUser: Command<TypeFromFields<{
                  credentialRule: FieldType<null | DoorLock.CredentialRule>;
                  operationType: FieldType<DoorLock.DataOperationType>;
                  userIndex: FieldType<number>;
                  userName: FieldType<null | string>;
                  userStatus: FieldType<null | DoorLock.UserStatus>;
                  userType: FieldType<null | DoorLock.UserType>;
                  userUniqueId: FieldType<null | number>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      user: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              setUserStatus: OptionalCommand<TypeFromFields<{
                  userId: FieldType<number>;
                  userStatus: FieldType<DoorLock.UserStatus>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      fingerCredentials: boolean;
                      pinCredential: boolean;
                      rfidCredential: boolean;
                      user: boolean;
                  }];
              };
              setUserType: OptionalCommand<TypeFromFields<{
                  userId: FieldType<number>;
                  userType: FieldType<DoorLock.UserType>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      fingerCredentials: boolean;
                      pinCredential: boolean;
                      rfidCredential: boolean;
                      user: boolean;
                  }];
              };
              setWeekDaySchedule: Command<TypeFromFields<{
                  daysMask: FieldType<TypeFromPartialBitSchema<{
                      friday: ...;
                      monday: ...;
                      saturday: ...;
                      sunday: ...;
                      thursday: ...;
                      tuesday: ...;
                      wednesday: ...;
                  }>>;
                  endHour: FieldType<number>;
                  endMinute: FieldType<number>;
                  startHour: FieldType<number>;
                  startMinute: FieldType<number>;
                  userIndexUserId: FieldType<number>;
                  weekDayIndex: FieldType<number>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      weekDayAccessSchedules: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              setYearDaySchedule: Command<TypeFromFields<{
                  localEndTime: FieldType<number>;
                  localStartTime: FieldType<number>;
                  userIndexUserId: FieldType<number>;
                  yearDayIndex: FieldType<number>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      yearDayAccessSchedules: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              unboltDoor: Command<TypeFromFields<{
                  pinCode: OptionalFieldType<Uint8Array>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      unbolting: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              unlockDoor: Command<TypeFromFields<{
                  pinCode: OptionalFieldType<Uint8Array>;
              }>, void, any>;
              unlockWithTimeout: OptionalCommand<TypeFromFields<{
                  pinCode: OptionalFieldType<Uint8Array>;
                  timeout: FieldType<number>;
              }>, void, any>;
          };
          events: {
              doorLockAlarm: Event<TypeFromFields<{
                  alarmCode: FieldType<DoorLock.AlarmCode>;
              }>, any>;
              doorStateChange: Event<TypeFromFields<{
                  doorState: FieldType<DoorLock.DoorState>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      doorPositionSensor: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              lockOperation: Event<TypeFromFields<{
                  credentials: OptionalFieldType<null | TypeFromFields<(...)>[]>;
                  fabricIndex: FieldType<null | FabricIndex>;
                  lockOperationType: FieldType<DoorLock.LockOperationType>;
                  operationSource: FieldType<DoorLock.OperationSource>;
                  sourceNode: FieldType<null | NodeId>;
                  userIndex: FieldType<null | number>;
              }>, any>;
              lockOperationError: Event<TypeFromFields<{
                  credentials: OptionalFieldType<null | TypeFromFields<(...)>[]>;
                  fabricIndex: FieldType<null | FabricIndex>;
                  lockOperationType: FieldType<DoorLock.LockOperationType>;
                  operationError: FieldType<DoorLock.OperationError>;
                  operationSource: FieldType<DoorLock.OperationSource>;
                  sourceNode: FieldType<null | NodeId>;
                  userIndex: FieldType<null | number>;
              }>, any>;
              lockUserChange: Event<TypeFromFields<{
                  dataIndex: FieldType<null | number>;
                  dataOperationType: FieldType<DoorLock.DataOperationType>;
                  fabricIndex: FieldType<null | FabricIndex>;
                  lockDataType: FieldType<DoorLock.LockDataType>;
                  operationSource: FieldType<DoorLock.OperationSource>;
                  sourceNode: FieldType<null | NodeId>;
                  userIndex: FieldType<null | number>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      user: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
          };
          features: {
              credentialOverTheAirAccess: BitFlag;
              doorPositionSensor: BitFlag;
              faceCredentials: BitFlag;
              fingerCredentials: BitFlag;
              holidaySchedules: BitFlag;
              logging: BitFlag;
              notification: BitFlag;
              pinCredential: BitFlag;
              rfidCredential: BitFlag;
              unbolting: BitFlag;
              user: BitFlag;
              weekDayAccessSchedules: BitFlag;
              yearDayAccessSchedules: BitFlag;
          };
          id: Branded<257, "ClusterId">;
          name: "DoorLock";
          revision: 7;
      }>>

    Parameters

    Returns WithFlags<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            actuatorEnabled: Attribute<boolean, any>;
            alarmMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                doorForcedOpen: BitFlag;
                frontEscutcheonRemoved: BitFlag;
                lockFactoryReset: BitFlag;
                lockJammed: BitFlag;
                lockRadioPowerCycled: BitFlag;
                na: BitFlag;
                wrongCodeEntryLimit: BitFlag;
            }>, any>;
            attributeList: Attribute<AttributeId[], never>;
            autoRelockTime: OptionalWritableAttribute<number, any>;
            clusterRevision: Attribute<number, never>;
            credentialRulesSupport: FixedAttribute<TypeFromPartialBitSchema<{
                dual: BitFlag;
                single: BitFlag;
                tri: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            defaultConfigurationRegister: OptionalAttribute<TypeFromPartialBitSchema<{
                autoRelockTime: BitFlag;
                keypadInterface: BitFlag;
                ledSettings: BitFlag;
                localProgramming: BitFlag;
                remoteInterface: BitFlag;
                soundVolume: BitFlag;
            }>, any>;
            doorClosedEvents: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    doorPositionSensor: boolean;
                }];
            };
            doorOpenEvents: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    doorPositionSensor: boolean;
                }];
            };
            doorState: Attribute<null | DoorLock.DoorState, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    doorPositionSensor: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            enableInsideStatusLed: OptionalWritableAttribute<boolean, any>;
            enableLocalProgramming: OptionalWritableAttribute<boolean, any>;
            enableLogging: WritableAttribute<boolean, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    logging: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            enableOneTouchLocking: OptionalWritableAttribute<boolean, any>;
            enablePrivacyModeButton: OptionalWritableAttribute<boolean, any>;
            expiringUserTimeout: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    user: boolean;
                }];
            };
            featureMap: Attribute<TypeFromPartialBitSchema<{
                credentialOverTheAirAccess: BitFlag;
                doorPositionSensor: BitFlag;
                faceCredentials: BitFlag;
                fingerCredentials: BitFlag;
                holidaySchedules: BitFlag;
                logging: BitFlag;
                notification: BitFlag;
                pinCredential: BitFlag;
                rfidCredential: BitFlag;
                unbolting: BitFlag;
                user: BitFlag;
                weekDayAccessSchedules: BitFlag;
                yearDayAccessSchedules: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            keypadOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                bit0: BitFlag;
                bit1: BitFlag;
                bit10: BitFlag;
                bit11: BitFlag;
                bit12: BitFlag;
                bit13: BitFlag;
                bit14: BitFlag;
                bit15: BitFlag;
                bit2: BitFlag;
                bit3: BitFlag;
                bit4: BitFlag;
                bit5: BitFlag;
                bit6: BitFlag;
                bit7: BitFlag;
                bit8: BitFlag;
                bit9: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                    pinCredential: boolean;
                }];
            };
            keypadProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                pinAdded: BitFlag;
                pinChanged: BitFlag;
                pinCleared: BitFlag;
                pinCodeChanged: BitFlag;
                unknown: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                    pinCredential: boolean;
                }];
            };
            language: OptionalWritableAttribute<string, any>;
            ledSettings: OptionalWritableAttribute<DoorLock.LedSetting, any>;
            localProgrammingFeatures: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                addUsersCredentialsSchedules: BitFlag;
                adjustSettings: BitFlag;
                clearUsersCredentialsSchedules: BitFlag;
                modifyUsersCredentialsSchedules: BitFlag;
            }>, any>;
            lockState: Attribute<null | DoorLock.LockState, any>;
            lockType: Attribute<DoorLock.LockType, any>;
            manualOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                bit0: BitFlag;
                bit1: BitFlag;
                bit10: BitFlag;
                bit11: BitFlag;
                bit12: BitFlag;
                bit13: BitFlag;
                bit14: BitFlag;
                bit15: BitFlag;
                bit2: BitFlag;
                bit3: BitFlag;
                bit4: BitFlag;
                bit5: BitFlag;
                bit6: BitFlag;
                bit7: BitFlag;
                bit8: BitFlag;
                bit9: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                }];
            };
            maxPinCodeLength: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            maxRfidCodeLength: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minPinCodeLength: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minRfidCodeLength: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfCredentialsSupportedPerUser: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfHolidaySchedulesSupported: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    holidaySchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfLogRecordsSupported: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    logging: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfPinUsersSupported: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfRfidUsersSupported: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfTotalUsersSupported: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfWeekDaySchedulesSupportedPerUser: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    weekDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfYearDaySchedulesSupportedPerUser: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    yearDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            openPeriod: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    doorPositionSensor: boolean;
                }];
            };
            operatingMode: WritableAttribute<DoorLock.OperatingMode, any>;
            remoteOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                bit0: BitFlag;
                bit1: BitFlag;
                bit10: BitFlag;
                bit11: BitFlag;
                bit12: BitFlag;
                bit13: BitFlag;
                bit14: BitFlag;
                bit15: BitFlag;
                bit2: BitFlag;
                bit3: BitFlag;
                bit4: BitFlag;
                bit5: BitFlag;
                bit6: BitFlag;
                bit7: BitFlag;
                bit8: BitFlag;
                bit9: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                }];
            };
            remoteProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                pinAdded: BitFlag;
                pinChanged: BitFlag;
                pinCleared: BitFlag;
                rfidCodeAdded: BitFlag;
                rfidCodeCleared: BitFlag;
                unknown: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                }];
            };
            requirePinForRemoteOperation: WritableAttribute<boolean, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    credentialOverTheAirAccess: boolean;
                    pinCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            rfidOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                bit0: BitFlag;
                bit1: BitFlag;
                bit10: BitFlag;
                bit11: BitFlag;
                bit12: BitFlag;
                bit13: BitFlag;
                bit14: BitFlag;
                bit15: BitFlag;
                bit2: BitFlag;
                bit3: BitFlag;
                bit4: BitFlag;
                bit5: BitFlag;
                bit6: BitFlag;
                bit7: BitFlag;
                bit8: BitFlag;
                bit9: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                    rfidCredential: boolean;
                }];
            };
            rfidProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                idAdded: BitFlag;
                idCleared: BitFlag;
                unknown: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                    rfidCredential: boolean;
                }];
            };
            sendPinOverTheAir: OptionalWritableAttribute<boolean, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    pinCredential: boolean;
                    user: boolean;
                }];
            };
            soundVolume: OptionalWritableAttribute<DoorLock.SoundVolume, any>;
            supportedOperatingModes: FixedAttribute<TypeFromPartialBitSchema<{
                noRemoteLockUnlock: BitFlag;
                normal: BitFlag;
                passage: BitFlag;
                privacy: BitFlag;
                vacation: BitFlag;
            }>, any>;
            userCodeTemporaryDisableTime: WritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                }, {
                    rfidCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            wrongCodeEntryLimit: WritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                }, {
                    rfidCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            clearAllPinCodes: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearAllRfidCodes: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearCredential: Command<TypeFromFields<{
                credential: FieldType<null | TypeFromFields<(...)>>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearHolidaySchedule: Command<TypeFromFields<{
                holidayIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    holidaySchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearPinCode: Command<TypeFromFields<{
                pinSlotIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearRfidCode: Command<TypeFromFields<{
                rfidSlotIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearUser: Command<TypeFromFields<{
                userIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearWeekDaySchedule: Command<TypeFromFields<{
                userIndexUserId: FieldType<number>;
                weekDayIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    weekDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearYearDaySchedule: Command<TypeFromFields<{
                userIndexUserId: FieldType<number>;
                yearDayIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    yearDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getCredentialStatus: Command<TypeFromFields<{
                credential: FieldType<TypeFromFields<{
                    credentialIndex: ...;
                    credentialType: ...;
                }>>;
            }>, TypeFromFields<{
                creatorFabricIndex: FieldType<null | FabricIndex>;
                credentialExists: FieldType<boolean>;
                lastModifiedFabricIndex: FieldType<null | FabricIndex>;
                nextCredentialIndex: OptionalFieldType<null | number>;
                userIndex: FieldType<null | number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getHolidaySchedule: Command<TypeFromFields<{
                holidayIndex: FieldType<number>;
            }>, TypeFromFields<{
                holidayIndex: FieldType<number>;
                localEndTime: OptionalFieldType<null | number>;
                localStartTime: OptionalFieldType<null | number>;
                operatingMode: OptionalFieldType<null | DoorLock.OperatingMode>;
                status: FieldType<Status>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    holidaySchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getLogRecord: Command<TypeFromFields<{
                logIndex: FieldType<number>;
            }>, TypeFromFields<{
                eventId: FieldType<number>;
                eventType: FieldType<DoorLock.EventType>;
                logEntryId: FieldType<number>;
                pin: FieldType<Uint8Array>;
                source: FieldType<DoorLock.EventSource>;
                timestamp: FieldType<number>;
                userId: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    logging: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getPinCode: Command<TypeFromFields<{
                userId: FieldType<number>;
            }>, TypeFromFields<{
                pinCode: FieldType<null | Uint8Array>;
                userId: FieldType<number>;
                userStatus: FieldType<null | DoorLock.UserStatus>;
                userType: FieldType<null | DoorLock.UserType>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getRfidCode: Command<TypeFromFields<{
                userId: FieldType<number>;
            }>, TypeFromFields<{
                rfidCode: FieldType<null | Uint8Array>;
                userId: FieldType<number>;
                userStatus: FieldType<null | DoorLock.UserStatus>;
                userType: FieldType<null | DoorLock.UserType>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getUser: Command<TypeFromFields<{
                userIndex: FieldType<number>;
            }>, TypeFromFields<{
                creatorFabricIndex: FieldType<null | FabricIndex>;
                credentialRule: FieldType<null | DoorLock.CredentialRule>;
                credentials: FieldType<null | (...)[]>;
                lastModifiedFabricIndex: FieldType<null | FabricIndex>;
                nextUserIndex: FieldType<null | number>;
                userIndex: FieldType<number>;
                userName: FieldType<null | string>;
                userStatus: FieldType<null | DoorLock.UserStatus>;
                userType: FieldType<null | DoorLock.UserType>;
                userUniqueId: FieldType<null | number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getUserStatus: OptionalCommand<TypeFromFields<{
                userId: FieldType<number>;
            }>, TypeFromFields<{
                userId: FieldType<number>;
                userStatus: FieldType<DoorLock.UserStatus>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    fingerCredentials: boolean;
                    pinCredential: boolean;
                    rfidCredential: boolean;
                    user: boolean;
                }];
            };
            getUserType: OptionalCommand<TypeFromFields<{
                userId: FieldType<number>;
            }>, TypeFromFields<{
                userId: FieldType<number>;
                userType: FieldType<DoorLock.UserType>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    fingerCredentials: boolean;
                    pinCredential: boolean;
                    rfidCredential: boolean;
                    user: boolean;
                }];
            };
            getWeekDaySchedule: Command<TypeFromFields<{
                userIndexUserId: FieldType<number>;
                weekDayIndex: FieldType<number>;
            }>, TypeFromFields<{
                daysMask: OptionalFieldType<TypeFromPartialBitSchema<{
                    friday: ...;
                    monday: ...;
                    saturday: ...;
                    sunday: ...;
                    thursday: ...;
                    tuesday: ...;
                    wednesday: ...;
                }>>;
                endHour: OptionalFieldType<number>;
                endMinute: OptionalFieldType<number>;
                startHour: OptionalFieldType<number>;
                startMinute: OptionalFieldType<number>;
                status: FieldType<Status>;
                userIndexUserId: FieldType<number>;
                weekDayIndex: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    weekDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getYearDaySchedule: Command<TypeFromFields<{
                userIndexUserId: FieldType<number>;
                yearDayIndex: FieldType<number>;
            }>, TypeFromFields<{
                localEndTime: OptionalFieldType<number>;
                localStartTime: OptionalFieldType<number>;
                status: FieldType<Status>;
                userIndexUserId: FieldType<number>;
                yearDayIndex: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    yearDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            lockDoor: Command<TypeFromFields<{
                pinCode: OptionalFieldType<Uint8Array>;
            }>, void, any>;
            setCredential: Command<TypeFromFields<{
                credential: FieldType<TypeFromFields<{
                    credentialIndex: ...;
                    credentialType: ...;
                }>>;
                credentialData: FieldType<Uint8Array>;
                operationType: FieldType<DoorLock.DataOperationType>;
                userIndex: FieldType<null | number>;
                userStatus: FieldType<null | DoorLock.UserStatus>;
                userType: FieldType<null | DoorLock.UserType>;
            }>, TypeFromFields<{
                nextCredentialIndex: OptionalFieldType<null | number>;
                status: FieldType<Status>;
                userIndex: FieldType<null | number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setHolidaySchedule: Command<TypeFromFields<{
                holidayIndex: FieldType<number>;
                localEndTime: FieldType<number>;
                localStartTime: FieldType<number>;
                operatingMode: FieldType<DoorLock.OperatingMode>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    holidaySchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setPinCode: Command<TypeFromFields<{
                pin: FieldType<Uint8Array>;
                userId: FieldType<number>;
                userStatus: FieldType<null | DoorLock.UserStatus>;
                userType: FieldType<null | DoorLock.UserType>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setRfidCode: Command<TypeFromFields<{
                rfidCode: FieldType<Uint8Array>;
                userId: FieldType<number>;
                userStatus: FieldType<null | DoorLock.UserStatus>;
                userType: FieldType<null | DoorLock.UserType>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setUser: Command<TypeFromFields<{
                credentialRule: FieldType<null | DoorLock.CredentialRule>;
                operationType: FieldType<DoorLock.DataOperationType>;
                userIndex: FieldType<number>;
                userName: FieldType<null | string>;
                userStatus: FieldType<null | DoorLock.UserStatus>;
                userType: FieldType<null | DoorLock.UserType>;
                userUniqueId: FieldType<null | number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setUserStatus: OptionalCommand<TypeFromFields<{
                userId: FieldType<number>;
                userStatus: FieldType<DoorLock.UserStatus>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    fingerCredentials: boolean;
                    pinCredential: boolean;
                    rfidCredential: boolean;
                    user: boolean;
                }];
            };
            setUserType: OptionalCommand<TypeFromFields<{
                userId: FieldType<number>;
                userType: FieldType<DoorLock.UserType>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    fingerCredentials: boolean;
                    pinCredential: boolean;
                    rfidCredential: boolean;
                    user: boolean;
                }];
            };
            setWeekDaySchedule: Command<TypeFromFields<{
                daysMask: FieldType<TypeFromPartialBitSchema<{
                    friday: ...;
                    monday: ...;
                    saturday: ...;
                    sunday: ...;
                    thursday: ...;
                    tuesday: ...;
                    wednesday: ...;
                }>>;
                endHour: FieldType<number>;
                endMinute: FieldType<number>;
                startHour: FieldType<number>;
                startMinute: FieldType<number>;
                userIndexUserId: FieldType<number>;
                weekDayIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    weekDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setYearDaySchedule: Command<TypeFromFields<{
                localEndTime: FieldType<number>;
                localStartTime: FieldType<number>;
                userIndexUserId: FieldType<number>;
                yearDayIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    yearDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            unboltDoor: Command<TypeFromFields<{
                pinCode: OptionalFieldType<Uint8Array>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    unbolting: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            unlockDoor: Command<TypeFromFields<{
                pinCode: OptionalFieldType<Uint8Array>;
            }>, void, any>;
            unlockWithTimeout: OptionalCommand<TypeFromFields<{
                pinCode: OptionalFieldType<Uint8Array>;
                timeout: FieldType<number>;
            }>, void, any>;
        };
        events: {
            doorLockAlarm: Event<TypeFromFields<{
                alarmCode: FieldType<DoorLock.AlarmCode>;
            }>, any>;
            doorStateChange: Event<TypeFromFields<{
                doorState: FieldType<DoorLock.DoorState>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    doorPositionSensor: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            lockOperation: Event<TypeFromFields<{
                credentials: OptionalFieldType<null | TypeFromFields<(...)>[]>;
                fabricIndex: FieldType<null | FabricIndex>;
                lockOperationType: FieldType<DoorLock.LockOperationType>;
                operationSource: FieldType<DoorLock.OperationSource>;
                sourceNode: FieldType<null | NodeId>;
                userIndex: FieldType<null | number>;
            }>, any>;
            lockOperationError: Event<TypeFromFields<{
                credentials: OptionalFieldType<null | TypeFromFields<(...)>[]>;
                fabricIndex: FieldType<null | FabricIndex>;
                lockOperationType: FieldType<DoorLock.LockOperationType>;
                operationError: FieldType<DoorLock.OperationError>;
                operationSource: FieldType<DoorLock.OperationSource>;
                sourceNode: FieldType<null | NodeId>;
                userIndex: FieldType<null | number>;
            }>, any>;
            lockUserChange: Event<TypeFromFields<{
                dataIndex: FieldType<null | number>;
                dataOperationType: FieldType<DoorLock.DataOperationType>;
                fabricIndex: FieldType<null | FabricIndex>;
                lockDataType: FieldType<DoorLock.LockDataType>;
                operationSource: FieldType<DoorLock.OperationSource>;
                sourceNode: FieldType<null | NodeId>;
                userIndex: FieldType<null | number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            credentialOverTheAirAccess: BitFlag;
            doorPositionSensor: BitFlag;
            faceCredentials: BitFlag;
            fingerCredentials: BitFlag;
            holidaySchedules: BitFlag;
            logging: BitFlag;
            notification: BitFlag;
            pinCredential: BitFlag;
            rfidCredential: BitFlag;
            unbolting: BitFlag;
            user: BitFlag;
            weekDayAccessSchedules: BitFlag;
            yearDayAccessSchedules: BitFlag;
        };
        id: Branded<257, "ClusterId">;
        name: "DoorLock";
        revision: 7;
    }>, FlagsT>

  • Modify elements using ElementModifier.set.

    Type Parameters

    • const ValuesT extends {
          actuatorEnabled: boolean;
          alarmMask?: {
              doorForcedOpen?: boolean;
              frontEscutcheonRemoved?: boolean;
              lockFactoryReset?: boolean;
              lockJammed?: boolean;
              lockRadioPowerCycled?: boolean;
              na?: boolean;
              wrongCodeEntryLimit?: boolean;
          };
          autoRelockTime?: number;
          credentialRulesSupport?: {
              dual?: boolean;
              single?: boolean;
              tri?: boolean;
          };
          defaultConfigurationRegister?: {
              autoRelockTime?: boolean;
              keypadInterface?: boolean;
              ledSettings?: boolean;
              localProgramming?: boolean;
              remoteInterface?: boolean;
              soundVolume?: boolean;
          };
          doorClosedEvents?: number;
          doorOpenEvents?: number;
          doorState?: null | number;
          enableInsideStatusLed?: boolean;
          enableLocalProgramming?: boolean;
          enableLogging?: boolean;
          enableOneTouchLocking?: boolean;
          enablePrivacyModeButton?: boolean;
          expiringUserTimeout?: number;
          keypadOperationEventMask?: {
              bit0?: boolean;
              bit1?: boolean;
              bit10?: boolean;
              bit11?: boolean;
              bit12?: boolean;
              bit13?: boolean;
              bit14?: boolean;
              bit15?: boolean;
              bit2?: boolean;
              bit3?: boolean;
              bit4?: boolean;
              bit5?: boolean;
              bit6?: boolean;
              bit7?: boolean;
              bit8?: boolean;
              bit9?: boolean;
          };
          keypadProgrammingEventMask?: {
              pinAdded?: boolean;
              pinChanged?: boolean;
              pinCleared?: boolean;
              pinCodeChanged?: boolean;
              unknown?: boolean;
          };
          language?: string;
          ledSettings?: number;
          localProgrammingFeatures?: {
              addUsersCredentialsSchedules?: boolean;
              adjustSettings?: boolean;
              clearUsersCredentialsSchedules?: boolean;
              modifyUsersCredentialsSchedules?: boolean;
          };
          lockState: null | number;
          lockType: number;
          manualOperationEventMask?: {
              bit0?: boolean;
              bit1?: boolean;
              bit10?: boolean;
              bit11?: boolean;
              bit12?: boolean;
              bit13?: boolean;
              bit14?: boolean;
              bit15?: boolean;
              bit2?: boolean;
              bit3?: boolean;
              bit4?: boolean;
              bit5?: boolean;
              bit6?: boolean;
              bit7?: boolean;
              bit8?: boolean;
              bit9?: boolean;
          };
          maxPinCodeLength?: number;
          maxRfidCodeLength?: number;
          minPinCodeLength?: number;
          minRfidCodeLength?: number;
          numberOfCredentialsSupportedPerUser?: number;
          numberOfHolidaySchedulesSupported?: number;
          numberOfLogRecordsSupported?: number;
          numberOfPinUsersSupported?: number;
          numberOfRfidUsersSupported?: number;
          numberOfTotalUsersSupported?: number;
          numberOfWeekDaySchedulesSupportedPerUser?: number;
          numberOfYearDaySchedulesSupportedPerUser?: number;
          openPeriod?: number;
          operatingMode: number;
          remoteOperationEventMask?: {
              bit0?: boolean;
              bit1?: boolean;
              bit10?: boolean;
              bit11?: boolean;
              bit12?: boolean;
              bit13?: boolean;
              bit14?: boolean;
              bit15?: boolean;
              bit2?: boolean;
              bit3?: boolean;
              bit4?: boolean;
              bit5?: boolean;
              bit6?: boolean;
              bit7?: boolean;
              bit8?: boolean;
              bit9?: boolean;
          };
          remoteProgrammingEventMask?: {
              pinAdded?: boolean;
              pinChanged?: boolean;
              pinCleared?: boolean;
              rfidCodeAdded?: boolean;
              rfidCodeCleared?: boolean;
              unknown?: boolean;
          };
          requirePinForRemoteOperation?: boolean;
          rfidOperationEventMask?: {
              bit0?: boolean;
              bit1?: boolean;
              bit10?: boolean;
              bit11?: boolean;
              bit12?: boolean;
              bit13?: boolean;
              bit14?: boolean;
              bit15?: boolean;
              bit2?: boolean;
              bit3?: boolean;
              bit4?: boolean;
              bit5?: boolean;
              bit6?: boolean;
              bit7?: boolean;
              bit8?: boolean;
              bit9?: boolean;
          };
          rfidProgrammingEventMask?: {
              idAdded?: boolean;
              idCleared?: boolean;
              unknown?: boolean;
          };
          sendPinOverTheAir?: boolean;
          soundVolume?: number;
          supportedOperatingModes: {
              noRemoteLockUnlock?: boolean;
              normal?: boolean;
              passage?: boolean;
              privacy?: boolean;
              vacation?: boolean;
          };
          userCodeTemporaryDisableTime?: number;
          wrongCodeEntryLimit?: number;
      }

    Parameters

    Returns WithValues<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            actuatorEnabled: Attribute<boolean, any>;
            alarmMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                doorForcedOpen: BitFlag;
                frontEscutcheonRemoved: BitFlag;
                lockFactoryReset: BitFlag;
                lockJammed: BitFlag;
                lockRadioPowerCycled: BitFlag;
                na: BitFlag;
                wrongCodeEntryLimit: BitFlag;
            }>, any>;
            attributeList: Attribute<AttributeId[], never>;
            autoRelockTime: OptionalWritableAttribute<number, any>;
            clusterRevision: Attribute<number, never>;
            credentialRulesSupport: FixedAttribute<TypeFromPartialBitSchema<{
                dual: BitFlag;
                single: BitFlag;
                tri: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            defaultConfigurationRegister: OptionalAttribute<TypeFromPartialBitSchema<{
                autoRelockTime: BitFlag;
                keypadInterface: BitFlag;
                ledSettings: BitFlag;
                localProgramming: BitFlag;
                remoteInterface: BitFlag;
                soundVolume: BitFlag;
            }>, any>;
            doorClosedEvents: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    doorPositionSensor: boolean;
                }];
            };
            doorOpenEvents: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    doorPositionSensor: boolean;
                }];
            };
            doorState: Attribute<null | DoorLock.DoorState, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    doorPositionSensor: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            enableInsideStatusLed: OptionalWritableAttribute<boolean, any>;
            enableLocalProgramming: OptionalWritableAttribute<boolean, any>;
            enableLogging: WritableAttribute<boolean, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    logging: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            enableOneTouchLocking: OptionalWritableAttribute<boolean, any>;
            enablePrivacyModeButton: OptionalWritableAttribute<boolean, any>;
            expiringUserTimeout: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    user: boolean;
                }];
            };
            featureMap: Attribute<TypeFromPartialBitSchema<{
                credentialOverTheAirAccess: BitFlag;
                doorPositionSensor: BitFlag;
                faceCredentials: BitFlag;
                fingerCredentials: BitFlag;
                holidaySchedules: BitFlag;
                logging: BitFlag;
                notification: BitFlag;
                pinCredential: BitFlag;
                rfidCredential: BitFlag;
                unbolting: BitFlag;
                user: BitFlag;
                weekDayAccessSchedules: BitFlag;
                yearDayAccessSchedules: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            keypadOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                bit0: BitFlag;
                bit1: BitFlag;
                bit10: BitFlag;
                bit11: BitFlag;
                bit12: BitFlag;
                bit13: BitFlag;
                bit14: BitFlag;
                bit15: BitFlag;
                bit2: BitFlag;
                bit3: BitFlag;
                bit4: BitFlag;
                bit5: BitFlag;
                bit6: BitFlag;
                bit7: BitFlag;
                bit8: BitFlag;
                bit9: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                    pinCredential: boolean;
                }];
            };
            keypadProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                pinAdded: BitFlag;
                pinChanged: BitFlag;
                pinCleared: BitFlag;
                pinCodeChanged: BitFlag;
                unknown: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                    pinCredential: boolean;
                }];
            };
            language: OptionalWritableAttribute<string, any>;
            ledSettings: OptionalWritableAttribute<DoorLock.LedSetting, any>;
            localProgrammingFeatures: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                addUsersCredentialsSchedules: BitFlag;
                adjustSettings: BitFlag;
                clearUsersCredentialsSchedules: BitFlag;
                modifyUsersCredentialsSchedules: BitFlag;
            }>, any>;
            lockState: Attribute<null | DoorLock.LockState, any>;
            lockType: Attribute<DoorLock.LockType, any>;
            manualOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                bit0: BitFlag;
                bit1: BitFlag;
                bit10: BitFlag;
                bit11: BitFlag;
                bit12: BitFlag;
                bit13: BitFlag;
                bit14: BitFlag;
                bit15: BitFlag;
                bit2: BitFlag;
                bit3: BitFlag;
                bit4: BitFlag;
                bit5: BitFlag;
                bit6: BitFlag;
                bit7: BitFlag;
                bit8: BitFlag;
                bit9: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                }];
            };
            maxPinCodeLength: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            maxRfidCodeLength: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minPinCodeLength: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minRfidCodeLength: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfCredentialsSupportedPerUser: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfHolidaySchedulesSupported: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    holidaySchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfLogRecordsSupported: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    logging: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfPinUsersSupported: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfRfidUsersSupported: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfTotalUsersSupported: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfWeekDaySchedulesSupportedPerUser: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    weekDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfYearDaySchedulesSupportedPerUser: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    yearDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            openPeriod: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    doorPositionSensor: boolean;
                }];
            };
            operatingMode: WritableAttribute<DoorLock.OperatingMode, any>;
            remoteOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                bit0: BitFlag;
                bit1: BitFlag;
                bit10: BitFlag;
                bit11: BitFlag;
                bit12: BitFlag;
                bit13: BitFlag;
                bit14: BitFlag;
                bit15: BitFlag;
                bit2: BitFlag;
                bit3: BitFlag;
                bit4: BitFlag;
                bit5: BitFlag;
                bit6: BitFlag;
                bit7: BitFlag;
                bit8: BitFlag;
                bit9: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                }];
            };
            remoteProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                pinAdded: BitFlag;
                pinChanged: BitFlag;
                pinCleared: BitFlag;
                rfidCodeAdded: BitFlag;
                rfidCodeCleared: BitFlag;
                unknown: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                }];
            };
            requirePinForRemoteOperation: WritableAttribute<boolean, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    credentialOverTheAirAccess: boolean;
                    pinCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            rfidOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                bit0: BitFlag;
                bit1: BitFlag;
                bit10: BitFlag;
                bit11: BitFlag;
                bit12: BitFlag;
                bit13: BitFlag;
                bit14: BitFlag;
                bit15: BitFlag;
                bit2: BitFlag;
                bit3: BitFlag;
                bit4: BitFlag;
                bit5: BitFlag;
                bit6: BitFlag;
                bit7: BitFlag;
                bit8: BitFlag;
                bit9: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                    rfidCredential: boolean;
                }];
            };
            rfidProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                idAdded: BitFlag;
                idCleared: BitFlag;
                unknown: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                    rfidCredential: boolean;
                }];
            };
            sendPinOverTheAir: OptionalWritableAttribute<boolean, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    pinCredential: boolean;
                    user: boolean;
                }];
            };
            soundVolume: OptionalWritableAttribute<DoorLock.SoundVolume, any>;
            supportedOperatingModes: FixedAttribute<TypeFromPartialBitSchema<{
                noRemoteLockUnlock: BitFlag;
                normal: BitFlag;
                passage: BitFlag;
                privacy: BitFlag;
                vacation: BitFlag;
            }>, any>;
            userCodeTemporaryDisableTime: WritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                }, {
                    rfidCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            wrongCodeEntryLimit: WritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                }, {
                    rfidCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            clearAllPinCodes: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearAllRfidCodes: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearCredential: Command<TypeFromFields<{
                credential: FieldType<null | TypeFromFields<(...)>>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearHolidaySchedule: Command<TypeFromFields<{
                holidayIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    holidaySchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearPinCode: Command<TypeFromFields<{
                pinSlotIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearRfidCode: Command<TypeFromFields<{
                rfidSlotIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearUser: Command<TypeFromFields<{
                userIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearWeekDaySchedule: Command<TypeFromFields<{
                userIndexUserId: FieldType<number>;
                weekDayIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    weekDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearYearDaySchedule: Command<TypeFromFields<{
                userIndexUserId: FieldType<number>;
                yearDayIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    yearDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getCredentialStatus: Command<TypeFromFields<{
                credential: FieldType<TypeFromFields<{
                    credentialIndex: ...;
                    credentialType: ...;
                }>>;
            }>, TypeFromFields<{
                creatorFabricIndex: FieldType<null | FabricIndex>;
                credentialExists: FieldType<boolean>;
                lastModifiedFabricIndex: FieldType<null | FabricIndex>;
                nextCredentialIndex: OptionalFieldType<null | number>;
                userIndex: FieldType<null | number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getHolidaySchedule: Command<TypeFromFields<{
                holidayIndex: FieldType<number>;
            }>, TypeFromFields<{
                holidayIndex: FieldType<number>;
                localEndTime: OptionalFieldType<null | number>;
                localStartTime: OptionalFieldType<null | number>;
                operatingMode: OptionalFieldType<null | DoorLock.OperatingMode>;
                status: FieldType<Status>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    holidaySchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getLogRecord: Command<TypeFromFields<{
                logIndex: FieldType<number>;
            }>, TypeFromFields<{
                eventId: FieldType<number>;
                eventType: FieldType<DoorLock.EventType>;
                logEntryId: FieldType<number>;
                pin: FieldType<Uint8Array>;
                source: FieldType<DoorLock.EventSource>;
                timestamp: FieldType<number>;
                userId: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    logging: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getPinCode: Command<TypeFromFields<{
                userId: FieldType<number>;
            }>, TypeFromFields<{
                pinCode: FieldType<null | Uint8Array>;
                userId: FieldType<number>;
                userStatus: FieldType<null | DoorLock.UserStatus>;
                userType: FieldType<null | DoorLock.UserType>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getRfidCode: Command<TypeFromFields<{
                userId: FieldType<number>;
            }>, TypeFromFields<{
                rfidCode: FieldType<null | Uint8Array>;
                userId: FieldType<number>;
                userStatus: FieldType<null | DoorLock.UserStatus>;
                userType: FieldType<null | DoorLock.UserType>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getUser: Command<TypeFromFields<{
                userIndex: FieldType<number>;
            }>, TypeFromFields<{
                creatorFabricIndex: FieldType<null | FabricIndex>;
                credentialRule: FieldType<null | DoorLock.CredentialRule>;
                credentials: FieldType<null | (...)[]>;
                lastModifiedFabricIndex: FieldType<null | FabricIndex>;
                nextUserIndex: FieldType<null | number>;
                userIndex: FieldType<number>;
                userName: FieldType<null | string>;
                userStatus: FieldType<null | DoorLock.UserStatus>;
                userType: FieldType<null | DoorLock.UserType>;
                userUniqueId: FieldType<null | number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getUserStatus: OptionalCommand<TypeFromFields<{
                userId: FieldType<number>;
            }>, TypeFromFields<{
                userId: FieldType<number>;
                userStatus: FieldType<DoorLock.UserStatus>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    fingerCredentials: boolean;
                    pinCredential: boolean;
                    rfidCredential: boolean;
                    user: boolean;
                }];
            };
            getUserType: OptionalCommand<TypeFromFields<{
                userId: FieldType<number>;
            }>, TypeFromFields<{
                userId: FieldType<number>;
                userType: FieldType<DoorLock.UserType>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    fingerCredentials: boolean;
                    pinCredential: boolean;
                    rfidCredential: boolean;
                    user: boolean;
                }];
            };
            getWeekDaySchedule: Command<TypeFromFields<{
                userIndexUserId: FieldType<number>;
                weekDayIndex: FieldType<number>;
            }>, TypeFromFields<{
                daysMask: OptionalFieldType<TypeFromPartialBitSchema<{
                    friday: ...;
                    monday: ...;
                    saturday: ...;
                    sunday: ...;
                    thursday: ...;
                    tuesday: ...;
                    wednesday: ...;
                }>>;
                endHour: OptionalFieldType<number>;
                endMinute: OptionalFieldType<number>;
                startHour: OptionalFieldType<number>;
                startMinute: OptionalFieldType<number>;
                status: FieldType<Status>;
                userIndexUserId: FieldType<number>;
                weekDayIndex: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    weekDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getYearDaySchedule: Command<TypeFromFields<{
                userIndexUserId: FieldType<number>;
                yearDayIndex: FieldType<number>;
            }>, TypeFromFields<{
                localEndTime: OptionalFieldType<number>;
                localStartTime: OptionalFieldType<number>;
                status: FieldType<Status>;
                userIndexUserId: FieldType<number>;
                yearDayIndex: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    yearDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            lockDoor: Command<TypeFromFields<{
                pinCode: OptionalFieldType<Uint8Array>;
            }>, void, any>;
            setCredential: Command<TypeFromFields<{
                credential: FieldType<TypeFromFields<{
                    credentialIndex: ...;
                    credentialType: ...;
                }>>;
                credentialData: FieldType<Uint8Array>;
                operationType: FieldType<DoorLock.DataOperationType>;
                userIndex: FieldType<null | number>;
                userStatus: FieldType<null | DoorLock.UserStatus>;
                userType: FieldType<null | DoorLock.UserType>;
            }>, TypeFromFields<{
                nextCredentialIndex: OptionalFieldType<null | number>;
                status: FieldType<Status>;
                userIndex: FieldType<null | number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setHolidaySchedule: Command<TypeFromFields<{
                holidayIndex: FieldType<number>;
                localEndTime: FieldType<number>;
                localStartTime: FieldType<number>;
                operatingMode: FieldType<DoorLock.OperatingMode>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    holidaySchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setPinCode: Command<TypeFromFields<{
                pin: FieldType<Uint8Array>;
                userId: FieldType<number>;
                userStatus: FieldType<null | DoorLock.UserStatus>;
                userType: FieldType<null | DoorLock.UserType>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setRfidCode: Command<TypeFromFields<{
                rfidCode: FieldType<Uint8Array>;
                userId: FieldType<number>;
                userStatus: FieldType<null | DoorLock.UserStatus>;
                userType: FieldType<null | DoorLock.UserType>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setUser: Command<TypeFromFields<{
                credentialRule: FieldType<null | DoorLock.CredentialRule>;
                operationType: FieldType<DoorLock.DataOperationType>;
                userIndex: FieldType<number>;
                userName: FieldType<null | string>;
                userStatus: FieldType<null | DoorLock.UserStatus>;
                userType: FieldType<null | DoorLock.UserType>;
                userUniqueId: FieldType<null | number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setUserStatus: OptionalCommand<TypeFromFields<{
                userId: FieldType<number>;
                userStatus: FieldType<DoorLock.UserStatus>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    fingerCredentials: boolean;
                    pinCredential: boolean;
                    rfidCredential: boolean;
                    user: boolean;
                }];
            };
            setUserType: OptionalCommand<TypeFromFields<{
                userId: FieldType<number>;
                userType: FieldType<DoorLock.UserType>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    fingerCredentials: boolean;
                    pinCredential: boolean;
                    rfidCredential: boolean;
                    user: boolean;
                }];
            };
            setWeekDaySchedule: Command<TypeFromFields<{
                daysMask: FieldType<TypeFromPartialBitSchema<{
                    friday: ...;
                    monday: ...;
                    saturday: ...;
                    sunday: ...;
                    thursday: ...;
                    tuesday: ...;
                    wednesday: ...;
                }>>;
                endHour: FieldType<number>;
                endMinute: FieldType<number>;
                startHour: FieldType<number>;
                startMinute: FieldType<number>;
                userIndexUserId: FieldType<number>;
                weekDayIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    weekDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setYearDaySchedule: Command<TypeFromFields<{
                localEndTime: FieldType<number>;
                localStartTime: FieldType<number>;
                userIndexUserId: FieldType<number>;
                yearDayIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    yearDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            unboltDoor: Command<TypeFromFields<{
                pinCode: OptionalFieldType<Uint8Array>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    unbolting: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            unlockDoor: Command<TypeFromFields<{
                pinCode: OptionalFieldType<Uint8Array>;
            }>, void, any>;
            unlockWithTimeout: OptionalCommand<TypeFromFields<{
                pinCode: OptionalFieldType<Uint8Array>;
                timeout: FieldType<number>;
            }>, void, any>;
        };
        events: {
            doorLockAlarm: Event<TypeFromFields<{
                alarmCode: FieldType<DoorLock.AlarmCode>;
            }>, any>;
            doorStateChange: Event<TypeFromFields<{
                doorState: FieldType<DoorLock.DoorState>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    doorPositionSensor: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            lockOperation: Event<TypeFromFields<{
                credentials: OptionalFieldType<null | TypeFromFields<(...)>[]>;
                fabricIndex: FieldType<null | FabricIndex>;
                lockOperationType: FieldType<DoorLock.LockOperationType>;
                operationSource: FieldType<DoorLock.OperationSource>;
                sourceNode: FieldType<null | NodeId>;
                userIndex: FieldType<null | number>;
            }>, any>;
            lockOperationError: Event<TypeFromFields<{
                credentials: OptionalFieldType<null | TypeFromFields<(...)>[]>;
                fabricIndex: FieldType<null | FabricIndex>;
                lockOperationType: FieldType<DoorLock.LockOperationType>;
                operationError: FieldType<DoorLock.OperationError>;
                operationSource: FieldType<DoorLock.OperationSource>;
                sourceNode: FieldType<null | NodeId>;
                userIndex: FieldType<null | number>;
            }>, any>;
            lockUserChange: Event<TypeFromFields<{
                dataIndex: FieldType<null | number>;
                dataOperationType: FieldType<DoorLock.DataOperationType>;
                fabricIndex: FieldType<null | FabricIndex>;
                lockDataType: FieldType<DoorLock.LockDataType>;
                operationSource: FieldType<DoorLock.OperationSource>;
                sourceNode: FieldType<null | NodeId>;
                userIndex: FieldType<null | number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            credentialOverTheAirAccess: BitFlag;
            doorPositionSensor: BitFlag;
            faceCredentials: BitFlag;
            fingerCredentials: BitFlag;
            holidaySchedules: BitFlag;
            logging: BitFlag;
            notification: BitFlag;
            pinCredential: BitFlag;
            rfidCredential: BitFlag;
            unbolting: BitFlag;
            user: BitFlag;
            weekDayAccessSchedules: BitFlag;
            yearDayAccessSchedules: BitFlag;
        };
        id: Branded<257, "ClusterId">;
        name: "DoorLock";
        revision: 7;
    }>, ValuesT>

  • Select features using ClusterComposer.compose.

    Type Parameters

    • const SelectionT extends FeatureSelection<Of<{
          attributes: {
              acceptedCommandList: Attribute<CommandId[], never>;
              actuatorEnabled: Attribute<boolean, any>;
              alarmMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                  doorForcedOpen: BitFlag;
                  frontEscutcheonRemoved: BitFlag;
                  lockFactoryReset: BitFlag;
                  lockJammed: BitFlag;
                  lockRadioPowerCycled: BitFlag;
                  na: BitFlag;
                  wrongCodeEntryLimit: BitFlag;
              }>, any>;
              attributeList: Attribute<AttributeId[], never>;
              autoRelockTime: OptionalWritableAttribute<number, any>;
              clusterRevision: Attribute<number, never>;
              credentialRulesSupport: FixedAttribute<TypeFromPartialBitSchema<{
                  dual: BitFlag;
                  single: BitFlag;
                  tri: BitFlag;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      user: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              defaultConfigurationRegister: OptionalAttribute<TypeFromPartialBitSchema<{
                  autoRelockTime: BitFlag;
                  keypadInterface: BitFlag;
                  ledSettings: BitFlag;
                  localProgramming: BitFlag;
                  remoteInterface: BitFlag;
                  soundVolume: BitFlag;
              }>, any>;
              doorClosedEvents: OptionalWritableAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      doorPositionSensor: boolean;
                  }];
              };
              doorOpenEvents: OptionalWritableAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      doorPositionSensor: boolean;
                  }];
              };
              doorState: Attribute<null | DoorLock.DoorState, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      doorPositionSensor: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              enableInsideStatusLed: OptionalWritableAttribute<boolean, any>;
              enableLocalProgramming: OptionalWritableAttribute<boolean, any>;
              enableLogging: WritableAttribute<boolean, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      logging: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              enableOneTouchLocking: OptionalWritableAttribute<boolean, any>;
              enablePrivacyModeButton: OptionalWritableAttribute<boolean, any>;
              expiringUserTimeout: OptionalWritableAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      user: boolean;
                  }];
              };
              featureMap: Attribute<TypeFromPartialBitSchema<{
                  credentialOverTheAirAccess: BitFlag;
                  doorPositionSensor: BitFlag;
                  faceCredentials: BitFlag;
                  fingerCredentials: BitFlag;
                  holidaySchedules: BitFlag;
                  logging: BitFlag;
                  notification: BitFlag;
                  pinCredential: BitFlag;
                  rfidCredential: BitFlag;
                  unbolting: BitFlag;
                  user: BitFlag;
                  weekDayAccessSchedules: BitFlag;
                  yearDayAccessSchedules: BitFlag;
              }>, never>;
              generatedCommandList: Attribute<CommandId[], never>;
              keypadOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                  bit0: BitFlag;
                  bit1: BitFlag;
                  bit10: BitFlag;
                  bit11: BitFlag;
                  bit12: BitFlag;
                  bit13: BitFlag;
                  bit14: BitFlag;
                  bit15: BitFlag;
                  bit2: BitFlag;
                  bit3: BitFlag;
                  bit4: BitFlag;
                  bit5: BitFlag;
                  bit6: BitFlag;
                  bit7: BitFlag;
                  bit8: BitFlag;
                  bit9: BitFlag;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      notification: boolean;
                      pinCredential: boolean;
                  }];
              };
              keypadProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                  pinAdded: BitFlag;
                  pinChanged: BitFlag;
                  pinCleared: BitFlag;
                  pinCodeChanged: BitFlag;
                  unknown: BitFlag;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      notification: boolean;
                      pinCredential: boolean;
                  }];
              };
              language: OptionalWritableAttribute<string, any>;
              ledSettings: OptionalWritableAttribute<DoorLock.LedSetting, any>;
              localProgrammingFeatures: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                  addUsersCredentialsSchedules: BitFlag;
                  adjustSettings: BitFlag;
                  clearUsersCredentialsSchedules: BitFlag;
                  modifyUsersCredentialsSchedules: BitFlag;
              }>, any>;
              lockState: Attribute<null | DoorLock.LockState, any>;
              lockType: Attribute<DoorLock.LockType, any>;
              manualOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                  bit0: BitFlag;
                  bit1: BitFlag;
                  bit10: BitFlag;
                  bit11: BitFlag;
                  bit12: BitFlag;
                  bit13: BitFlag;
                  bit14: BitFlag;
                  bit15: BitFlag;
                  bit2: BitFlag;
                  bit3: BitFlag;
                  bit4: BitFlag;
                  bit5: BitFlag;
                  bit6: BitFlag;
                  bit7: BitFlag;
                  bit8: BitFlag;
                  bit9: BitFlag;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      notification: boolean;
                  }];
              };
              maxPinCodeLength: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      pinCredential: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              maxRfidCodeLength: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      rfidCredential: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              minPinCodeLength: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      pinCredential: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              minRfidCodeLength: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      rfidCredential: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              numberOfCredentialsSupportedPerUser: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      user: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              numberOfHolidaySchedulesSupported: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      holidaySchedules: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              numberOfLogRecordsSupported: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      logging: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              numberOfPinUsersSupported: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      pinCredential: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              numberOfRfidUsersSupported: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      rfidCredential: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              numberOfTotalUsersSupported: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      user: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              numberOfWeekDaySchedulesSupportedPerUser: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      weekDayAccessSchedules: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              numberOfYearDaySchedulesSupportedPerUser: FixedAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      yearDayAccessSchedules: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              openPeriod: OptionalWritableAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      doorPositionSensor: boolean;
                  }];
              };
              operatingMode: WritableAttribute<DoorLock.OperatingMode, any>;
              remoteOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                  bit0: BitFlag;
                  bit1: BitFlag;
                  bit10: BitFlag;
                  bit11: BitFlag;
                  bit12: BitFlag;
                  bit13: BitFlag;
                  bit14: BitFlag;
                  bit15: BitFlag;
                  bit2: BitFlag;
                  bit3: BitFlag;
                  bit4: BitFlag;
                  bit5: BitFlag;
                  bit6: BitFlag;
                  bit7: BitFlag;
                  bit8: BitFlag;
                  bit9: BitFlag;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      notification: boolean;
                  }];
              };
              remoteProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                  pinAdded: BitFlag;
                  pinChanged: BitFlag;
                  pinCleared: BitFlag;
                  rfidCodeAdded: BitFlag;
                  rfidCodeCleared: BitFlag;
                  unknown: BitFlag;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      notification: boolean;
                  }];
              };
              requirePinForRemoteOperation: WritableAttribute<boolean, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      credentialOverTheAirAccess: boolean;
                      pinCredential: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              rfidOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                  bit0: BitFlag;
                  bit1: BitFlag;
                  bit10: BitFlag;
                  bit11: BitFlag;
                  bit12: BitFlag;
                  bit13: BitFlag;
                  bit14: BitFlag;
                  bit15: BitFlag;
                  bit2: BitFlag;
                  bit3: BitFlag;
                  bit4: BitFlag;
                  bit5: BitFlag;
                  bit6: BitFlag;
                  bit7: BitFlag;
                  bit8: BitFlag;
                  bit9: BitFlag;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      notification: boolean;
                      rfidCredential: boolean;
                  }];
              };
              rfidProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                  idAdded: BitFlag;
                  idCleared: BitFlag;
                  unknown: BitFlag;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      notification: boolean;
                      rfidCredential: boolean;
                  }];
              };
              sendPinOverTheAir: OptionalWritableAttribute<boolean, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      pinCredential: boolean;
                      user: boolean;
                  }];
              };
              soundVolume: OptionalWritableAttribute<DoorLock.SoundVolume, any>;
              supportedOperatingModes: FixedAttribute<TypeFromPartialBitSchema<{
                  noRemoteLockUnlock: BitFlag;
                  normal: BitFlag;
                  passage: BitFlag;
                  privacy: BitFlag;
                  vacation: BitFlag;
              }>, any>;
              userCodeTemporaryDisableTime: WritableAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      pinCredential: boolean;
                  }, {
                      rfidCredential: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              wrongCodeEntryLimit: WritableAttribute<number, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      pinCredential: boolean;
                  }, {
                      rfidCredential: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
          };
          commands: {
              clearAllPinCodes: Command<void, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      pinCredential: boolean;
                      user: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              clearAllRfidCodes: Command<void, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      rfidCredential: boolean;
                      user: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              clearCredential: Command<TypeFromFields<{
                  credential: FieldType<null | TypeFromFields<(...)>>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      user: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              clearHolidaySchedule: Command<TypeFromFields<{
                  holidayIndex: FieldType<number>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      holidaySchedules: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              clearPinCode: Command<TypeFromFields<{
                  pinSlotIndex: FieldType<number>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      pinCredential: boolean;
                      user: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              clearRfidCode: Command<TypeFromFields<{
                  rfidSlotIndex: FieldType<number>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      rfidCredential: boolean;
                      user: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              clearUser: Command<TypeFromFields<{
                  userIndex: FieldType<number>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      user: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              clearWeekDaySchedule: Command<TypeFromFields<{
                  userIndexUserId: FieldType<number>;
                  weekDayIndex: FieldType<number>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      weekDayAccessSchedules: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              clearYearDaySchedule: Command<TypeFromFields<{
                  userIndexUserId: FieldType<number>;
                  yearDayIndex: FieldType<number>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      yearDayAccessSchedules: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              getCredentialStatus: Command<TypeFromFields<{
                  credential: FieldType<TypeFromFields<{
                      credentialIndex: ...;
                      credentialType: ...;
                  }>>;
              }>, TypeFromFields<{
                  creatorFabricIndex: FieldType<null | FabricIndex>;
                  credentialExists: FieldType<boolean>;
                  lastModifiedFabricIndex: FieldType<null | FabricIndex>;
                  nextCredentialIndex: OptionalFieldType<null | number>;
                  userIndex: FieldType<null | number>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      user: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              getHolidaySchedule: Command<TypeFromFields<{
                  holidayIndex: FieldType<number>;
              }>, TypeFromFields<{
                  holidayIndex: FieldType<number>;
                  localEndTime: OptionalFieldType<null | number>;
                  localStartTime: OptionalFieldType<null | number>;
                  operatingMode: OptionalFieldType<null | DoorLock.OperatingMode>;
                  status: FieldType<Status>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      holidaySchedules: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              getLogRecord: Command<TypeFromFields<{
                  logIndex: FieldType<number>;
              }>, TypeFromFields<{
                  eventId: FieldType<number>;
                  eventType: FieldType<DoorLock.EventType>;
                  logEntryId: FieldType<number>;
                  pin: FieldType<Uint8Array>;
                  source: FieldType<DoorLock.EventSource>;
                  timestamp: FieldType<number>;
                  userId: FieldType<number>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      logging: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              getPinCode: Command<TypeFromFields<{
                  userId: FieldType<number>;
              }>, TypeFromFields<{
                  pinCode: FieldType<null | Uint8Array>;
                  userId: FieldType<number>;
                  userStatus: FieldType<null | DoorLock.UserStatus>;
                  userType: FieldType<null | DoorLock.UserType>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      pinCredential: boolean;
                      user: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              getRfidCode: Command<TypeFromFields<{
                  userId: FieldType<number>;
              }>, TypeFromFields<{
                  rfidCode: FieldType<null | Uint8Array>;
                  userId: FieldType<number>;
                  userStatus: FieldType<null | DoorLock.UserStatus>;
                  userType: FieldType<null | DoorLock.UserType>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      rfidCredential: boolean;
                      user: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              getUser: Command<TypeFromFields<{
                  userIndex: FieldType<number>;
              }>, TypeFromFields<{
                  creatorFabricIndex: FieldType<null | FabricIndex>;
                  credentialRule: FieldType<null | DoorLock.CredentialRule>;
                  credentials: FieldType<null | (...)[]>;
                  lastModifiedFabricIndex: FieldType<null | FabricIndex>;
                  nextUserIndex: FieldType<null | number>;
                  userIndex: FieldType<number>;
                  userName: FieldType<null | string>;
                  userStatus: FieldType<null | DoorLock.UserStatus>;
                  userType: FieldType<null | DoorLock.UserType>;
                  userUniqueId: FieldType<null | number>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      user: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              getUserStatus: OptionalCommand<TypeFromFields<{
                  userId: FieldType<number>;
              }>, TypeFromFields<{
                  userId: FieldType<number>;
                  userStatus: FieldType<DoorLock.UserStatus>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      fingerCredentials: boolean;
                      pinCredential: boolean;
                      rfidCredential: boolean;
                      user: boolean;
                  }];
              };
              getUserType: OptionalCommand<TypeFromFields<{
                  userId: FieldType<number>;
              }>, TypeFromFields<{
                  userId: FieldType<number>;
                  userType: FieldType<DoorLock.UserType>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      fingerCredentials: boolean;
                      pinCredential: boolean;
                      rfidCredential: boolean;
                      user: boolean;
                  }];
              };
              getWeekDaySchedule: Command<TypeFromFields<{
                  userIndexUserId: FieldType<number>;
                  weekDayIndex: FieldType<number>;
              }>, TypeFromFields<{
                  daysMask: OptionalFieldType<TypeFromPartialBitSchema<{
                      friday: ...;
                      monday: ...;
                      saturday: ...;
                      sunday: ...;
                      thursday: ...;
                      tuesday: ...;
                      wednesday: ...;
                  }>>;
                  endHour: OptionalFieldType<number>;
                  endMinute: OptionalFieldType<number>;
                  startHour: OptionalFieldType<number>;
                  startMinute: OptionalFieldType<number>;
                  status: FieldType<Status>;
                  userIndexUserId: FieldType<number>;
                  weekDayIndex: FieldType<number>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      weekDayAccessSchedules: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              getYearDaySchedule: Command<TypeFromFields<{
                  userIndexUserId: FieldType<number>;
                  yearDayIndex: FieldType<number>;
              }>, TypeFromFields<{
                  localEndTime: OptionalFieldType<number>;
                  localStartTime: OptionalFieldType<number>;
                  status: FieldType<Status>;
                  userIndexUserId: FieldType<number>;
                  yearDayIndex: FieldType<number>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      yearDayAccessSchedules: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              lockDoor: Command<TypeFromFields<{
                  pinCode: OptionalFieldType<Uint8Array>;
              }>, void, any>;
              setCredential: Command<TypeFromFields<{
                  credential: FieldType<TypeFromFields<{
                      credentialIndex: ...;
                      credentialType: ...;
                  }>>;
                  credentialData: FieldType<Uint8Array>;
                  operationType: FieldType<DoorLock.DataOperationType>;
                  userIndex: FieldType<null | number>;
                  userStatus: FieldType<null | DoorLock.UserStatus>;
                  userType: FieldType<null | DoorLock.UserType>;
              }>, TypeFromFields<{
                  nextCredentialIndex: OptionalFieldType<null | number>;
                  status: FieldType<Status>;
                  userIndex: FieldType<null | number>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      user: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              setHolidaySchedule: Command<TypeFromFields<{
                  holidayIndex: FieldType<number>;
                  localEndTime: FieldType<number>;
                  localStartTime: FieldType<number>;
                  operatingMode: FieldType<DoorLock.OperatingMode>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      holidaySchedules: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              setPinCode: Command<TypeFromFields<{
                  pin: FieldType<Uint8Array>;
                  userId: FieldType<number>;
                  userStatus: FieldType<null | DoorLock.UserStatus>;
                  userType: FieldType<null | DoorLock.UserType>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      pinCredential: boolean;
                      user: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              setRfidCode: Command<TypeFromFields<{
                  rfidCode: FieldType<Uint8Array>;
                  userId: FieldType<number>;
                  userStatus: FieldType<null | DoorLock.UserStatus>;
                  userType: FieldType<null | DoorLock.UserType>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      rfidCredential: boolean;
                      user: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              setUser: Command<TypeFromFields<{
                  credentialRule: FieldType<null | DoorLock.CredentialRule>;
                  operationType: FieldType<DoorLock.DataOperationType>;
                  userIndex: FieldType<number>;
                  userName: FieldType<null | string>;
                  userStatus: FieldType<null | DoorLock.UserStatus>;
                  userType: FieldType<null | DoorLock.UserType>;
                  userUniqueId: FieldType<null | number>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      user: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              setUserStatus: OptionalCommand<TypeFromFields<{
                  userId: FieldType<number>;
                  userStatus: FieldType<DoorLock.UserStatus>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      fingerCredentials: boolean;
                      pinCredential: boolean;
                      rfidCredential: boolean;
                      user: boolean;
                  }];
              };
              setUserType: OptionalCommand<TypeFromFields<{
                  userId: FieldType<number>;
                  userType: FieldType<DoorLock.UserType>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                  optional: true;
                  optionalIf: [] | [{
                      fingerCredentials: boolean;
                      pinCredential: boolean;
                      rfidCredential: boolean;
                      user: boolean;
                  }];
              };
              setWeekDaySchedule: Command<TypeFromFields<{
                  daysMask: FieldType<TypeFromPartialBitSchema<{
                      friday: ...;
                      monday: ...;
                      saturday: ...;
                      sunday: ...;
                      thursday: ...;
                      tuesday: ...;
                      wednesday: ...;
                  }>>;
                  endHour: FieldType<number>;
                  endMinute: FieldType<number>;
                  startHour: FieldType<number>;
                  startMinute: FieldType<number>;
                  userIndexUserId: FieldType<number>;
                  weekDayIndex: FieldType<number>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      weekDayAccessSchedules: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              setYearDaySchedule: Command<TypeFromFields<{
                  localEndTime: FieldType<number>;
                  localStartTime: FieldType<number>;
                  userIndexUserId: FieldType<number>;
                  yearDayIndex: FieldType<number>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      yearDayAccessSchedules: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              unboltDoor: Command<TypeFromFields<{
                  pinCode: OptionalFieldType<Uint8Array>;
              }>, void, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      unbolting: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              unlockDoor: Command<TypeFromFields<{
                  pinCode: OptionalFieldType<Uint8Array>;
              }>, void, any>;
              unlockWithTimeout: OptionalCommand<TypeFromFields<{
                  pinCode: OptionalFieldType<Uint8Array>;
                  timeout: FieldType<number>;
              }>, void, any>;
          };
          events: {
              doorLockAlarm: Event<TypeFromFields<{
                  alarmCode: FieldType<DoorLock.AlarmCode>;
              }>, any>;
              doorStateChange: Event<TypeFromFields<{
                  doorState: FieldType<DoorLock.DoorState>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      doorPositionSensor: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
              lockOperation: Event<TypeFromFields<{
                  credentials: OptionalFieldType<null | TypeFromFields<(...)>[]>;
                  fabricIndex: FieldType<null | FabricIndex>;
                  lockOperationType: FieldType<DoorLock.LockOperationType>;
                  operationSource: FieldType<DoorLock.OperationSource>;
                  sourceNode: FieldType<null | NodeId>;
                  userIndex: FieldType<null | number>;
              }>, any>;
              lockOperationError: Event<TypeFromFields<{
                  credentials: OptionalFieldType<null | TypeFromFields<(...)>[]>;
                  fabricIndex: FieldType<null | FabricIndex>;
                  lockOperationType: FieldType<DoorLock.LockOperationType>;
                  operationError: FieldType<DoorLock.OperationError>;
                  operationSource: FieldType<DoorLock.OperationSource>;
                  sourceNode: FieldType<null | NodeId>;
                  userIndex: FieldType<null | number>;
              }>, any>;
              lockUserChange: Event<TypeFromFields<{
                  dataIndex: FieldType<null | number>;
                  dataOperationType: FieldType<DoorLock.DataOperationType>;
                  fabricIndex: FieldType<null | FabricIndex>;
                  lockDataType: FieldType<DoorLock.LockDataType>;
                  operationSource: FieldType<DoorLock.OperationSource>;
                  sourceNode: FieldType<null | NodeId>;
                  userIndex: FieldType<null | number>;
              }>, any> & {
                  isConditional: true;
                  mandatoryIf: [] | [{
                      user: boolean;
                  }];
                  optional: true;
                  optionalIf: [] | ConditionalFeatureList<BitSchema>;
              };
          };
          features: {
              credentialOverTheAirAccess: BitFlag;
              doorPositionSensor: BitFlag;
              faceCredentials: BitFlag;
              fingerCredentials: BitFlag;
              holidaySchedules: BitFlag;
              logging: BitFlag;
              notification: BitFlag;
              pinCredential: BitFlag;
              rfidCredential: BitFlag;
              unbolting: BitFlag;
              user: BitFlag;
              weekDayAccessSchedules: BitFlag;
              yearDayAccessSchedules: BitFlag;
          };
          id: Branded<257, "ClusterId">;
          name: "DoorLock";
          revision: 7;
      }>>

    Parameters

    Returns Of<Of<{
        attributes: {
            acceptedCommandList: Attribute<CommandId[], never>;
            actuatorEnabled: Attribute<boolean, any>;
            alarmMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                doorForcedOpen: BitFlag;
                frontEscutcheonRemoved: BitFlag;
                lockFactoryReset: BitFlag;
                lockJammed: BitFlag;
                lockRadioPowerCycled: BitFlag;
                na: BitFlag;
                wrongCodeEntryLimit: BitFlag;
            }>, any>;
            attributeList: Attribute<AttributeId[], never>;
            autoRelockTime: OptionalWritableAttribute<number, any>;
            clusterRevision: Attribute<number, never>;
            credentialRulesSupport: FixedAttribute<TypeFromPartialBitSchema<{
                dual: BitFlag;
                single: BitFlag;
                tri: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            defaultConfigurationRegister: OptionalAttribute<TypeFromPartialBitSchema<{
                autoRelockTime: BitFlag;
                keypadInterface: BitFlag;
                ledSettings: BitFlag;
                localProgramming: BitFlag;
                remoteInterface: BitFlag;
                soundVolume: BitFlag;
            }>, any>;
            doorClosedEvents: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    doorPositionSensor: boolean;
                }];
            };
            doorOpenEvents: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    doorPositionSensor: boolean;
                }];
            };
            doorState: Attribute<null | DoorLock.DoorState, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    doorPositionSensor: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            enableInsideStatusLed: OptionalWritableAttribute<boolean, any>;
            enableLocalProgramming: OptionalWritableAttribute<boolean, any>;
            enableLogging: WritableAttribute<boolean, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    logging: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            enableOneTouchLocking: OptionalWritableAttribute<boolean, any>;
            enablePrivacyModeButton: OptionalWritableAttribute<boolean, any>;
            expiringUserTimeout: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    user: boolean;
                }];
            };
            featureMap: Attribute<TypeFromPartialBitSchema<{
                credentialOverTheAirAccess: BitFlag;
                doorPositionSensor: BitFlag;
                faceCredentials: BitFlag;
                fingerCredentials: BitFlag;
                holidaySchedules: BitFlag;
                logging: BitFlag;
                notification: BitFlag;
                pinCredential: BitFlag;
                rfidCredential: BitFlag;
                unbolting: BitFlag;
                user: BitFlag;
                weekDayAccessSchedules: BitFlag;
                yearDayAccessSchedules: BitFlag;
            }>, never>;
            generatedCommandList: Attribute<CommandId[], never>;
            keypadOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                bit0: BitFlag;
                bit1: BitFlag;
                bit10: BitFlag;
                bit11: BitFlag;
                bit12: BitFlag;
                bit13: BitFlag;
                bit14: BitFlag;
                bit15: BitFlag;
                bit2: BitFlag;
                bit3: BitFlag;
                bit4: BitFlag;
                bit5: BitFlag;
                bit6: BitFlag;
                bit7: BitFlag;
                bit8: BitFlag;
                bit9: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                    pinCredential: boolean;
                }];
            };
            keypadProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                pinAdded: BitFlag;
                pinChanged: BitFlag;
                pinCleared: BitFlag;
                pinCodeChanged: BitFlag;
                unknown: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                    pinCredential: boolean;
                }];
            };
            language: OptionalWritableAttribute<string, any>;
            ledSettings: OptionalWritableAttribute<DoorLock.LedSetting, any>;
            localProgrammingFeatures: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                addUsersCredentialsSchedules: BitFlag;
                adjustSettings: BitFlag;
                clearUsersCredentialsSchedules: BitFlag;
                modifyUsersCredentialsSchedules: BitFlag;
            }>, any>;
            lockState: Attribute<null | DoorLock.LockState, any>;
            lockType: Attribute<DoorLock.LockType, any>;
            manualOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                bit0: BitFlag;
                bit1: BitFlag;
                bit10: BitFlag;
                bit11: BitFlag;
                bit12: BitFlag;
                bit13: BitFlag;
                bit14: BitFlag;
                bit15: BitFlag;
                bit2: BitFlag;
                bit3: BitFlag;
                bit4: BitFlag;
                bit5: BitFlag;
                bit6: BitFlag;
                bit7: BitFlag;
                bit8: BitFlag;
                bit9: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                }];
            };
            maxPinCodeLength: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            maxRfidCodeLength: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minPinCodeLength: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            minRfidCodeLength: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfCredentialsSupportedPerUser: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfHolidaySchedulesSupported: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    holidaySchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfLogRecordsSupported: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    logging: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfPinUsersSupported: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfRfidUsersSupported: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfTotalUsersSupported: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfWeekDaySchedulesSupportedPerUser: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    weekDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            numberOfYearDaySchedulesSupportedPerUser: FixedAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    yearDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            openPeriod: OptionalWritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    doorPositionSensor: boolean;
                }];
            };
            operatingMode: WritableAttribute<DoorLock.OperatingMode, any>;
            remoteOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                bit0: BitFlag;
                bit1: BitFlag;
                bit10: BitFlag;
                bit11: BitFlag;
                bit12: BitFlag;
                bit13: BitFlag;
                bit14: BitFlag;
                bit15: BitFlag;
                bit2: BitFlag;
                bit3: BitFlag;
                bit4: BitFlag;
                bit5: BitFlag;
                bit6: BitFlag;
                bit7: BitFlag;
                bit8: BitFlag;
                bit9: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                }];
            };
            remoteProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                pinAdded: BitFlag;
                pinChanged: BitFlag;
                pinCleared: BitFlag;
                rfidCodeAdded: BitFlag;
                rfidCodeCleared: BitFlag;
                unknown: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                }];
            };
            requirePinForRemoteOperation: WritableAttribute<boolean, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    credentialOverTheAirAccess: boolean;
                    pinCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            rfidOperationEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                bit0: BitFlag;
                bit1: BitFlag;
                bit10: BitFlag;
                bit11: BitFlag;
                bit12: BitFlag;
                bit13: BitFlag;
                bit14: BitFlag;
                bit15: BitFlag;
                bit2: BitFlag;
                bit3: BitFlag;
                bit4: BitFlag;
                bit5: BitFlag;
                bit6: BitFlag;
                bit7: BitFlag;
                bit8: BitFlag;
                bit9: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                    rfidCredential: boolean;
                }];
            };
            rfidProgrammingEventMask: OptionalWritableAttribute<TypeFromPartialBitSchema<{
                idAdded: BitFlag;
                idCleared: BitFlag;
                unknown: BitFlag;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    notification: boolean;
                    rfidCredential: boolean;
                }];
            };
            sendPinOverTheAir: OptionalWritableAttribute<boolean, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    pinCredential: boolean;
                    user: boolean;
                }];
            };
            soundVolume: OptionalWritableAttribute<DoorLock.SoundVolume, any>;
            supportedOperatingModes: FixedAttribute<TypeFromPartialBitSchema<{
                noRemoteLockUnlock: BitFlag;
                normal: BitFlag;
                passage: BitFlag;
                privacy: BitFlag;
                vacation: BitFlag;
            }>, any>;
            userCodeTemporaryDisableTime: WritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                }, {
                    rfidCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            wrongCodeEntryLimit: WritableAttribute<number, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                }, {
                    rfidCredential: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        commands: {
            clearAllPinCodes: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearAllRfidCodes: Command<void, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearCredential: Command<TypeFromFields<{
                credential: FieldType<null | TypeFromFields<(...)>>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearHolidaySchedule: Command<TypeFromFields<{
                holidayIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    holidaySchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearPinCode: Command<TypeFromFields<{
                pinSlotIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearRfidCode: Command<TypeFromFields<{
                rfidSlotIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearUser: Command<TypeFromFields<{
                userIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearWeekDaySchedule: Command<TypeFromFields<{
                userIndexUserId: FieldType<number>;
                weekDayIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    weekDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            clearYearDaySchedule: Command<TypeFromFields<{
                userIndexUserId: FieldType<number>;
                yearDayIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    yearDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getCredentialStatus: Command<TypeFromFields<{
                credential: FieldType<TypeFromFields<{
                    credentialIndex: ...;
                    credentialType: ...;
                }>>;
            }>, TypeFromFields<{
                creatorFabricIndex: FieldType<null | FabricIndex>;
                credentialExists: FieldType<boolean>;
                lastModifiedFabricIndex: FieldType<null | FabricIndex>;
                nextCredentialIndex: OptionalFieldType<null | number>;
                userIndex: FieldType<null | number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getHolidaySchedule: Command<TypeFromFields<{
                holidayIndex: FieldType<number>;
            }>, TypeFromFields<{
                holidayIndex: FieldType<number>;
                localEndTime: OptionalFieldType<null | number>;
                localStartTime: OptionalFieldType<null | number>;
                operatingMode: OptionalFieldType<null | DoorLock.OperatingMode>;
                status: FieldType<Status>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    holidaySchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getLogRecord: Command<TypeFromFields<{
                logIndex: FieldType<number>;
            }>, TypeFromFields<{
                eventId: FieldType<number>;
                eventType: FieldType<DoorLock.EventType>;
                logEntryId: FieldType<number>;
                pin: FieldType<Uint8Array>;
                source: FieldType<DoorLock.EventSource>;
                timestamp: FieldType<number>;
                userId: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    logging: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getPinCode: Command<TypeFromFields<{
                userId: FieldType<number>;
            }>, TypeFromFields<{
                pinCode: FieldType<null | Uint8Array>;
                userId: FieldType<number>;
                userStatus: FieldType<null | DoorLock.UserStatus>;
                userType: FieldType<null | DoorLock.UserType>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getRfidCode: Command<TypeFromFields<{
                userId: FieldType<number>;
            }>, TypeFromFields<{
                rfidCode: FieldType<null | Uint8Array>;
                userId: FieldType<number>;
                userStatus: FieldType<null | DoorLock.UserStatus>;
                userType: FieldType<null | DoorLock.UserType>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getUser: Command<TypeFromFields<{
                userIndex: FieldType<number>;
            }>, TypeFromFields<{
                creatorFabricIndex: FieldType<null | FabricIndex>;
                credentialRule: FieldType<null | DoorLock.CredentialRule>;
                credentials: FieldType<null | (...)[]>;
                lastModifiedFabricIndex: FieldType<null | FabricIndex>;
                nextUserIndex: FieldType<null | number>;
                userIndex: FieldType<number>;
                userName: FieldType<null | string>;
                userStatus: FieldType<null | DoorLock.UserStatus>;
                userType: FieldType<null | DoorLock.UserType>;
                userUniqueId: FieldType<null | number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getUserStatus: OptionalCommand<TypeFromFields<{
                userId: FieldType<number>;
            }>, TypeFromFields<{
                userId: FieldType<number>;
                userStatus: FieldType<DoorLock.UserStatus>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    fingerCredentials: boolean;
                    pinCredential: boolean;
                    rfidCredential: boolean;
                    user: boolean;
                }];
            };
            getUserType: OptionalCommand<TypeFromFields<{
                userId: FieldType<number>;
            }>, TypeFromFields<{
                userId: FieldType<number>;
                userType: FieldType<DoorLock.UserType>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    fingerCredentials: boolean;
                    pinCredential: boolean;
                    rfidCredential: boolean;
                    user: boolean;
                }];
            };
            getWeekDaySchedule: Command<TypeFromFields<{
                userIndexUserId: FieldType<number>;
                weekDayIndex: FieldType<number>;
            }>, TypeFromFields<{
                daysMask: OptionalFieldType<TypeFromPartialBitSchema<{
                    friday: ...;
                    monday: ...;
                    saturday: ...;
                    sunday: ...;
                    thursday: ...;
                    tuesday: ...;
                    wednesday: ...;
                }>>;
                endHour: OptionalFieldType<number>;
                endMinute: OptionalFieldType<number>;
                startHour: OptionalFieldType<number>;
                startMinute: OptionalFieldType<number>;
                status: FieldType<Status>;
                userIndexUserId: FieldType<number>;
                weekDayIndex: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    weekDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            getYearDaySchedule: Command<TypeFromFields<{
                userIndexUserId: FieldType<number>;
                yearDayIndex: FieldType<number>;
            }>, TypeFromFields<{
                localEndTime: OptionalFieldType<number>;
                localStartTime: OptionalFieldType<number>;
                status: FieldType<Status>;
                userIndexUserId: FieldType<number>;
                yearDayIndex: FieldType<number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    yearDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            lockDoor: Command<TypeFromFields<{
                pinCode: OptionalFieldType<Uint8Array>;
            }>, void, any>;
            setCredential: Command<TypeFromFields<{
                credential: FieldType<TypeFromFields<{
                    credentialIndex: ...;
                    credentialType: ...;
                }>>;
                credentialData: FieldType<Uint8Array>;
                operationType: FieldType<DoorLock.DataOperationType>;
                userIndex: FieldType<null | number>;
                userStatus: FieldType<null | DoorLock.UserStatus>;
                userType: FieldType<null | DoorLock.UserType>;
            }>, TypeFromFields<{
                nextCredentialIndex: OptionalFieldType<null | number>;
                status: FieldType<Status>;
                userIndex: FieldType<null | number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setHolidaySchedule: Command<TypeFromFields<{
                holidayIndex: FieldType<number>;
                localEndTime: FieldType<number>;
                localStartTime: FieldType<number>;
                operatingMode: FieldType<DoorLock.OperatingMode>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    holidaySchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setPinCode: Command<TypeFromFields<{
                pin: FieldType<Uint8Array>;
                userId: FieldType<number>;
                userStatus: FieldType<null | DoorLock.UserStatus>;
                userType: FieldType<null | DoorLock.UserType>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    pinCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setRfidCode: Command<TypeFromFields<{
                rfidCode: FieldType<Uint8Array>;
                userId: FieldType<number>;
                userStatus: FieldType<null | DoorLock.UserStatus>;
                userType: FieldType<null | DoorLock.UserType>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    rfidCredential: boolean;
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setUser: Command<TypeFromFields<{
                credentialRule: FieldType<null | DoorLock.CredentialRule>;
                operationType: FieldType<DoorLock.DataOperationType>;
                userIndex: FieldType<number>;
                userName: FieldType<null | string>;
                userStatus: FieldType<null | DoorLock.UserStatus>;
                userType: FieldType<null | DoorLock.UserType>;
                userUniqueId: FieldType<null | number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setUserStatus: OptionalCommand<TypeFromFields<{
                userId: FieldType<number>;
                userStatus: FieldType<DoorLock.UserStatus>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    fingerCredentials: boolean;
                    pinCredential: boolean;
                    rfidCredential: boolean;
                    user: boolean;
                }];
            };
            setUserType: OptionalCommand<TypeFromFields<{
                userId: FieldType<number>;
                userType: FieldType<DoorLock.UserType>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | ConditionalFeatureList<BitSchema>;
                optional: true;
                optionalIf: [] | [{
                    fingerCredentials: boolean;
                    pinCredential: boolean;
                    rfidCredential: boolean;
                    user: boolean;
                }];
            };
            setWeekDaySchedule: Command<TypeFromFields<{
                daysMask: FieldType<TypeFromPartialBitSchema<{
                    friday: ...;
                    monday: ...;
                    saturday: ...;
                    sunday: ...;
                    thursday: ...;
                    tuesday: ...;
                    wednesday: ...;
                }>>;
                endHour: FieldType<number>;
                endMinute: FieldType<number>;
                startHour: FieldType<number>;
                startMinute: FieldType<number>;
                userIndexUserId: FieldType<number>;
                weekDayIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    weekDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            setYearDaySchedule: Command<TypeFromFields<{
                localEndTime: FieldType<number>;
                localStartTime: FieldType<number>;
                userIndexUserId: FieldType<number>;
                yearDayIndex: FieldType<number>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    yearDayAccessSchedules: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            unboltDoor: Command<TypeFromFields<{
                pinCode: OptionalFieldType<Uint8Array>;
            }>, void, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    unbolting: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            unlockDoor: Command<TypeFromFields<{
                pinCode: OptionalFieldType<Uint8Array>;
            }>, void, any>;
            unlockWithTimeout: OptionalCommand<TypeFromFields<{
                pinCode: OptionalFieldType<Uint8Array>;
                timeout: FieldType<number>;
            }>, void, any>;
        };
        events: {
            doorLockAlarm: Event<TypeFromFields<{
                alarmCode: FieldType<DoorLock.AlarmCode>;
            }>, any>;
            doorStateChange: Event<TypeFromFields<{
                doorState: FieldType<DoorLock.DoorState>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    doorPositionSensor: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
            lockOperation: Event<TypeFromFields<{
                credentials: OptionalFieldType<null | TypeFromFields<(...)>[]>;
                fabricIndex: FieldType<null | FabricIndex>;
                lockOperationType: FieldType<DoorLock.LockOperationType>;
                operationSource: FieldType<DoorLock.OperationSource>;
                sourceNode: FieldType<null | NodeId>;
                userIndex: FieldType<null | number>;
            }>, any>;
            lockOperationError: Event<TypeFromFields<{
                credentials: OptionalFieldType<null | TypeFromFields<(...)>[]>;
                fabricIndex: FieldType<null | FabricIndex>;
                lockOperationType: FieldType<DoorLock.LockOperationType>;
                operationError: FieldType<DoorLock.OperationError>;
                operationSource: FieldType<DoorLock.OperationSource>;
                sourceNode: FieldType<null | NodeId>;
                userIndex: FieldType<null | number>;
            }>, any>;
            lockUserChange: Event<TypeFromFields<{
                dataIndex: FieldType<null | number>;
                dataOperationType: FieldType<DoorLock.DataOperationType>;
                fabricIndex: FieldType<null | FabricIndex>;
                lockDataType: FieldType<DoorLock.LockDataType>;
                operationSource: FieldType<DoorLock.OperationSource>;
                sourceNode: FieldType<null | NodeId>;
                userIndex: FieldType<null | number>;
            }>, any> & {
                isConditional: true;
                mandatoryIf: [] | [{
                    user: boolean;
                }];
                optional: true;
                optionalIf: [] | ConditionalFeatureList<BitSchema>;
            };
        };
        features: {
            credentialOverTheAirAccess: BitFlag;
            doorPositionSensor: BitFlag;
            faceCredentials: BitFlag;
            fingerCredentials: BitFlag;
            holidaySchedules: BitFlag;
            logging: BitFlag;
            notification: BitFlag;
            pinCredential: BitFlag;
            rfidCredential: BitFlag;
            unbolting: BitFlag;
            user: BitFlag;
            weekDayAccessSchedules: BitFlag;
            yearDayAccessSchedules: BitFlag;
        };
        id: Branded<257, "ClusterId">;
        name: "DoorLock";
        revision: 7;
    }>, SelectionT>